WEBVTT

0:00:02.760000 --> 0:00:08.240000
 Hello and welcome to this video titled,
 Identifying the Network Bits.

0:00:08.240000 --> 0:00:12.640000
 In this video we're going to cover
 IP version 4 address classes.

0:00:12.640000 --> 0:00:16.920000
 We're going to determine how to figure
 out what class and address belongs

0:00:16.920000 --> 0:00:22.460000
 to. And I'm going to introduce to you
 the concept of an IP version 4 subnet

0:00:22.460000 --> 0:00:24.960000
 mask and what it is
 and why we need it.

0:00:24.960000 --> 0:00:29.940000
 And then we'll finish up with
 IP version 4 address types.

0:00:29.940000 --> 0:00:35.700000
 So let's start by looking at
 IP version 4 address classes.

0:00:35.700000 --> 0:00:40.100000
 Now if you've studied IP version 4,
 you know that one of the critical

0:00:40.100000 --> 0:00:43.840000
 components of the IP version
 4 header is the address.

0:00:43.840000 --> 0:00:47.460000
 There's a destination address of where
 a packet's going and a source address

0:00:47.460000 --> 0:00:49.620000
 of where a packet's coming from.

0:00:49.620000 --> 0:00:54.500000
 And you also know that when a device
 like your laptop or tablet creates

0:00:54.500000 --> 0:00:58.200000
 a packet, it puts its own address
 and there's a source.

0:00:58.200000 --> 0:01:01.860000
 And it puts in the destination of wherever
 it's trying to reach like INE

0:01:01.860000 --> 0:01:06.560000
.com's destination IP address or
 Google's destination IP address.

0:01:06.560000 --> 0:01:11.340000
 But before that packet can get going,
 the next thing that has to happen

0:01:11.340000 --> 0:01:15.020000
 is that device has to do a comparison
 of those two addresses.

0:01:15.020000 --> 0:01:19.400000
 And I have to say okay, is the destination
 I'm trying to reach in the

0:01:19.400000 --> 0:01:24.860000
 same network as me because that will
 influence how I transmit this packet

0:01:24.860000 --> 0:01:30.560000
 or is the destination I'm trying to
 reach not in the same network as me.

0:01:30.560000 --> 0:01:32.140000
 Well here's the kicker.

0:01:32.140000 --> 0:01:36.480000
 Those two addresses are just
 32 bit binary numbers.

0:01:36.480000 --> 0:01:40.700000
 There's a 32 bit binary number for the
 destination, a 32 bit binary number

0:01:40.700000 --> 0:01:44.960000
 for the source. So how does
 it answer that question?

0:01:44.960000 --> 0:01:49.200000
 Well, the way it does that is because
 it looks at its source address.

0:01:49.200000 --> 0:01:53.920000
 And the device won't look at its source
 address, it has to know somehow

0:01:53.920000 --> 0:01:59.580000
 of those 32 bits that there's some bits
 in the beginning that form a common

0:01:59.580000 --> 0:02:04.100000
 pattern for everybody that is
 on its own local network.

0:02:04.100000 --> 0:02:09.360000
 In other words, if I'm sitting in the
 payroll department and let's say

0:02:09.360000 --> 0:02:13.540000
 that the IP address I've been given
 in binary looks like this.

0:02:13.540000 --> 0:02:17.740000
 I'm not going to do 32 bits but let's
 just put some random bits in here.

0:02:17.740000 --> 0:02:23.840000
 My laptop somehow has to know that
 this right here is a binary pattern

0:02:23.840000 --> 0:02:28.300000
 that's common to everybody else
 in the payroll department.

0:02:28.300000 --> 0:02:29.840000
 That's my department.

0:02:29.840000 --> 0:02:34.240000
 So if I create a packet and the destination
 of the packet matches this

0:02:34.240000 --> 0:02:38.360000
 exact same pattern, I know that
 destination is in my network.

0:02:38.360000 --> 0:02:42.480000
 If the destination of the packet has
 some pattern different than this,

0:02:42.480000 --> 0:02:45.460000
 then I know it's not in my network and
 I have to forward that packet to

0:02:45.460000 --> 0:02:49.940000
 a router. So now we have to answer
 the question, if this is the number

0:02:49.940000 --> 0:02:56.260000
 I have, how do I know where this dividing
 line is between my networking

0:02:56.260000 --> 0:02:59.300000
 bits which tell me what group
 or department I'm in.

0:02:59.300000 --> 0:03:02.420000
 I'm a part of and my host bits.

0:03:02.420000 --> 0:03:04.200000
 How do I know where that is?

0:03:04.200000 --> 0:03:08.380000
 Well, let's start with the way the
 old timers did it and then we'll go

0:03:08.380000 --> 0:03:12.480000
 into the way we've done it for
 the last couple of decades.

0:03:12.480000 --> 0:03:18.660000
 So originally when IPv4 was first invented
 way back in RFC 791, we're

0:03:18.660000 --> 0:03:23.380000
 talking about the really
 early 1980s here.

0:03:23.380000 --> 0:03:27.820000
 The developers of IP version 4, they
 said, hey, IP version 4 is going

0:03:27.820000 --> 0:03:28.840000
 to have an address.

0:03:28.840000 --> 0:03:32.880000
 The address is going to be subdividable
 via a network portion and a host

0:03:32.880000 --> 0:03:36.840000
 portion. Okay, how is the device going
 to know where that dividing line

0:03:36.840000 --> 0:03:41.480000
 is? The original developers of IP version
 4, they said, okay, here's what

0:03:41.480000 --> 0:03:42.340000
 we're going to do.

0:03:42.340000 --> 0:03:46.180000
 We're going to divide addresses
 into what's called classes.

0:03:46.180000 --> 0:03:51.340000
 And depending on what class and addresses
 in, we'll automatically tell

0:03:51.340000 --> 0:03:54.280000
 you where that dividing line is.

0:03:54.280000 --> 0:03:58.700000
 Now, how does the device know, so we're
 talking about like 40 years ago

0:03:58.700000 --> 0:04:02.500000
 here, well, 30, 40 years ago, how does
 the device know what class of address

0:04:02.500000 --> 0:04:08.600000
 it has? Well, it was based on the
 very first few bits in binary.

0:04:08.600000 --> 0:04:13.420000
 So remember, computers look at this address
 as just a 32-bit binary number.

0:04:13.420000 --> 0:04:18.160000
 So back in the old days, they would
 look at the first few bits, so if

0:04:18.160000 --> 0:04:22.060000
 we read it from like left to right,
 the first few bits and just the bit

0:04:22.060000 --> 0:04:26.540000
 pattern alone would tell it what
 class of address it was.

0:04:26.540000 --> 0:04:30.060000
 And now that it knew what class of
 address it was, it would be able to

0:04:30.060000 --> 0:04:36.260000
 distinguish where the networking bits
 ended and where the host bits began.

0:04:36.260000 --> 0:04:39.060000
 Okay, so how did that happen?

0:04:39.060000 --> 0:04:42.240000
 Well, so let's take a look
 at those patterns.

0:04:42.240000 --> 0:04:46.360000
 So the first class of address
 is called a class A address.

0:04:46.360000 --> 0:04:51.560000
 Any IP address that in binary starts
 with a zero, if that's the very first

0:04:51.560000 --> 0:04:54.200000
 binary bit from left
 to right, we're done.

0:04:54.200000 --> 0:04:56.760000
 That is a class A address.

0:04:56.760000 --> 0:05:01.140000
 And according to these rules way back
 decades ago, a class A address said,

0:05:01.140000 --> 0:05:06.000000
 hey, your networking bits are the
 first eight bits, the first byte.

0:05:06.000000 --> 0:05:08.420000
 That's your network.

0:05:08.420000 --> 0:05:10.180000
 Now, what if it wasn't a zero?

0:05:10.180000 --> 0:05:11.640000
 Well, then we had
 to keep moving on.

0:05:11.640000 --> 0:05:15.440000
 Then we looked at if it was a one,
 then we looked at the next bit.

0:05:15.440000 --> 0:05:19.620000
 If the next bit was a zero, so now
 if we had a one zero, we're done.

0:05:19.620000 --> 0:05:21.800000
 That's a class B address.

0:05:21.800000 --> 0:05:26.040000
 And using class full addressing, that
 meant that the first half of your

0:05:26.040000 --> 0:05:28.320000
 address was the networking bits.

0:05:28.320000 --> 0:05:29.740000
 That's the department
 you're on now.

0:05:29.740000 --> 0:05:32.780000
 That's the common pattern that you
 and everybody else in your network

0:05:32.780000 --> 0:05:35.960000
 share is the first half.

0:05:35.960000 --> 0:05:41.400000
 Now, if the pattern was a one one
 zero, that was a class C address.

0:05:41.400000 --> 0:05:44.000000
 And you can probably guess
 where this is going.

0:05:44.000000 --> 0:05:50.060000
 Now the first three octets
 denoted your network.

0:05:50.060000 --> 0:05:53.400000
 Now, there were two other
 address types as well.

0:05:53.400000 --> 0:05:55.400000
 And I'm going to show you those
 here in just one second.

0:05:55.400000 --> 0:05:56.500000
 They are on the slide.

0:05:56.500000 --> 0:06:01.940000
 But I want to preface it by saying that
 when it came to assigning IP addresses

0:06:01.940000 --> 0:06:08.280000
 to hosts like laptops, PCs, servers,
 router interfaces, all the addresses

0:06:08.280000 --> 0:06:11.580000
 you can assign to a particular host
 are going to fall in one of these

0:06:11.580000 --> 0:06:15.160000
 three ranges here, A, B or C.

0:06:15.160000 --> 0:06:18.920000
 So the next two ranges I'm going to
 finish up with on this slide are not

0:06:18.920000 --> 0:06:21.920000
 used for addressing hosts.

0:06:21.920000 --> 0:06:27.680000
 In other words, a knit card on a laptop
 or server or smartphone will never

0:06:27.680000 --> 0:06:31.440000
 have an address that is in
 the next two categories.

0:06:31.440000 --> 0:06:32.800000
 So what are those two categories?

0:06:32.800000 --> 0:06:35.380000
 Well, you can probably figure out what
 the bit pattern is going to be

0:06:35.380000 --> 0:06:39.300000
 next. One one one zero.

0:06:39.300000 --> 0:06:42.780000
 That is a class D address.

0:06:42.780000 --> 0:06:45.360000
 That is reserved for something special
 that we'll talk about towards the

0:06:45.360000 --> 0:06:48.560000
 end of this video, which
 is called multicasting.

0:06:48.560000 --> 0:06:52.260000
 So whenever an application is doing
 multicasting of somebody says, hey,

0:06:52.260000 --> 0:06:55.360000
 I'm doing IP version for
 multicasting right there.

0:06:55.360000 --> 0:06:59.000000
 You know, oh, the destination
 address, the destination.

0:06:59.000000 --> 0:07:02.060000
 This is only used for destinations,
 not sources.

0:07:02.060000 --> 0:07:05.460000
 The destination of that packet would
 be something in binary beginning

0:07:05.460000 --> 0:07:07.780000
 with one one one zero.

0:07:07.780000 --> 0:07:11.660000
 And then class E, that
 was experimental.

0:07:11.660000 --> 0:07:13.220000
 That was never actually
 implemented.

0:07:13.220000 --> 0:07:14.560000
 That was never used.

0:07:14.560000 --> 0:07:18.080000
 As a matter of fact, if you go on to
 pretty much any operating system,

0:07:18.080000 --> 0:07:22.640000
 whether it be Windows, Mac OS, whatever,
 and you try manually giving it,

0:07:22.640000 --> 0:07:27.440000
 statically typing in an IP address
 that's in the class E range, you'll

0:07:27.440000 --> 0:07:28.540000
 get an error message.

0:07:28.540000 --> 0:07:31.700000
 Every single operating system knows
 that that is untouchable.

0:07:31.700000 --> 0:07:33.160000
 That is experimental.

0:07:33.160000 --> 0:07:35.780000
 That was never opened up for use.

0:07:35.780000 --> 0:07:38.320000
 So that's just a waste of space.

0:07:38.320000 --> 0:07:46.140000
 Okay. Well, this worked for the first
 handful of years of the life of

0:07:46.140000 --> 0:07:47.860000
 IP version four.

0:07:47.860000 --> 0:07:52.460000
 But it didn't take too long after IP
 version four was originally invented

0:07:52.460000 --> 0:07:57.780000
 that the developers of it said, wow, this
 is really catching on like wildfire.

0:07:57.780000 --> 0:08:01.320000
 I mean, networks are sprouting
 up all over the place.

0:08:01.320000 --> 0:08:03.120000
 It's getting crazy out there.

0:08:03.120000 --> 0:08:08.240000
 And this way of doing the address of
 determining where the network and

0:08:08.240000 --> 0:08:12.000000
 the host bits are isn't going to work
 for too much longer because there's

0:08:12.000000 --> 0:08:17.420000
 only a certain finite number of networks
 available in class A, class B,

0:08:17.420000 --> 0:08:18.600000
 and class C space.

0:08:18.600000 --> 0:08:21.020000
 And they were running
 out pretty fast.

0:08:21.020000 --> 0:08:24.300000
 So they said, okay, we need to come
 up with something different.

0:08:24.300000 --> 0:08:26.760000
 Classful networks, not scalable.

0:08:26.760000 --> 0:08:32.380000
 So we need to have some other way of
 just arbitrarily setting that line.

0:08:32.380000 --> 0:08:35.960000
 Why can't we have the line between
 where the network bits end and the

0:08:35.960000 --> 0:08:37.040000
 host bits begin?

0:08:37.040000 --> 0:08:41.600000
 Why don't we have that after the first
 nine bits or the first twelve bits

0:08:41.600000 --> 0:08:44.540000
 or maybe the first
 twenty one bits?

0:08:44.540000 --> 0:08:48.940000
 We should give the people the ability
 to arbitrarily set that dividing

0:08:48.940000 --> 0:08:53.460000
 line between where the network bits
 end and where the host bits begin.

0:08:53.460000 --> 0:08:57.720000
 And this is where this concept of
 a subnet mask was introduced.

0:08:57.720000 --> 0:09:00.180000
 So this was introduced
 way back in 1985.

0:09:00.180000 --> 0:09:04.620000
 If you want to read the original RFC
 for it online, you can Google RFC

0:09:04.620000 --> 0:09:10.240000
 950. And then a few years later, okay,
 so we're talking about what eight

0:09:10.240000 --> 0:09:16.040000
 years later, this thing called classless
 interdomain routing, classless

0:09:16.040000 --> 0:09:20.080000
 interdomain routing, sometimes called
 cedar, was introduced in 1993.

0:09:20.080000 --> 0:09:25.120000
 And that's when classful addressing
 was formally deprecated.

0:09:25.120000 --> 0:09:28.980000
 They said, okay, from this point on,
 nobody should do classful addressing

0:09:28.980000 --> 0:09:33.420000
 anymore. At this point, everybody
 needs to use subnet masks.

0:09:33.420000 --> 0:09:37.380000
 All right, well, what the heck is a
 subnet mask and how does it replace

0:09:37.380000 --> 0:09:39.360000
 classful addressing?

0:09:39.360000 --> 0:09:40.700000
 Well, here's how it works.

0:09:40.700000 --> 0:09:42.280000
 So here's your IP address.

0:09:42.280000 --> 0:09:45.940000
 Here's your 32-bit number
 as your computer sees it.

0:09:45.940000 --> 0:09:49.520000
 Now, if this was a classful address,
 you know, if we were talking about

0:09:49.520000 --> 0:09:54.620000
 1980 or something, the computer would
 say, oh, okay, I see right here,

0:09:54.620000 --> 0:09:56.620000
 the first bit is a zero.

0:09:56.620000 --> 0:10:01.800000
 So that tells me this is a class A address,
 which tells me that the first

0:10:01.800000 --> 0:10:04.640000
 eight bits are my network.

0:10:04.640000 --> 0:10:08.580000
 So that's my pattern, okay, but
 we're not doing that anymore.

0:10:08.580000 --> 0:10:11.700000
 So if you can't use a class,
 what can you use?

0:10:11.700000 --> 0:10:14.080000
 Well, here's the thing.

0:10:14.080000 --> 0:10:19.080000
 Every device that runs IP for the last
 couple of decades, when it learns

0:10:19.080000 --> 0:10:25.740000
 or is given an IP address, you have
 to also give it a subnet mask, which

0:10:25.740000 --> 0:10:27.860000
 is another binary number.

0:10:27.860000 --> 0:10:29.880000
 But it's a comparison tool.

0:10:29.880000 --> 0:10:34.700000
 The subnet mask is compared directly
 against the IP address, and this

0:10:34.700000 --> 0:10:39.240000
 helps the device that has the IP address
 answer that question about where

0:10:39.240000 --> 0:10:42.360000
 the network bits end and where
 the host bits begin.

0:10:42.360000 --> 0:10:44.760000
 And it's a real simple comparison.


0:10:44.760000 --> 0:10:49.200000
 So in any subnet mask you see, it'll
 start out with some continuous or

0:10:49.200000 --> 0:10:55.560000
 contiguous section of ones, and at some
 point, those one bits will end,

0:10:55.560000 --> 0:10:59.440000
 and now you'll have contiguous
 zeros all the way to the end.

0:10:59.440000 --> 0:11:02.600000
 So basically what you're going to do
 is you're going to pay it or your

0:11:02.600000 --> 0:11:07.920000
 computer would look at those one bits,
 and then would say, okay, going

0:11:07.920000 --> 0:11:10.800000
 left to right, how many
 one bits do I have?

0:11:10.800000 --> 0:11:15.240000
 Okay, in this case I think I've drawn
 out like 12 one bits or something

0:11:15.240000 --> 0:11:21.120000
 like that. So now it's going to go
 to its IP address and say, okay, if

0:11:21.120000 --> 0:11:26.920000
 the first 12 bits of my subnet mask
 were ones, and I didn't count that

0:11:26.920000 --> 0:11:31.780000
 up, but I think it's 12 bits, then
 that means the first 12 bits of my

0:11:31.780000 --> 0:11:35.060000
 IP address is my network.

0:11:35.060000 --> 0:11:38.340000
 That's where the dividing line is.


0:11:38.340000 --> 0:11:42.080000
 So you can see here, now we've identified
 our networking bits because

0:11:42.080000 --> 0:11:46.800000
 we just basically layered the subnet
 mask on top of the IP address, and

0:11:46.800000 --> 0:11:48.380000
 so one for one comparison.

0:11:48.380000 --> 0:11:53.440000
 Hey, if that's subnet mask, if that's
 subnet mask, only had the very first

0:11:53.440000 --> 0:11:58.660000
 two bits set as ones, one one and then
 zeros or zeros, and that would

0:11:58.660000 --> 0:12:03.900000
 mean that in my IP address, only the
 first two bits belong to my group.

0:12:03.900000 --> 0:12:06.080000
 Only the first two bits
 were my network.

0:12:06.080000 --> 0:12:10.880000
 Now you're not ever going to see that,
 but that's how the logic of the

0:12:10.880000 --> 0:12:12.360000
 subnet mask works.

0:12:12.360000 --> 0:12:15.660000
 So we're no longer, so this is
 classless inter-domain routing.

0:12:15.660000 --> 0:12:18.600000
 We're no longer looking at
 the class of an address.

0:12:18.600000 --> 0:12:20.380000
 Class is irrelevant now.

0:12:20.380000 --> 0:12:25.760000
 Now every IP address has to come bundled
 with a subnet mask, and the subnet

0:12:25.760000 --> 0:12:29.560000
 mask tells you where those networking
 bits end and where the host bits

0:12:29.560000 --> 0:12:38.780000
 begin. Okay, let's talk about different
 types of IP addresses.

0:12:38.780000 --> 0:12:46.100000
 So some IP addresses, most IP addresses,
 are what we call unicast addresses,

0:12:46.100000 --> 0:12:49.420000
 and these are used for one
-to-one communication.

0:12:49.420000 --> 0:12:54.720000
 So these utilize addresses in
 the class A, B, and C space.

0:12:54.720000 --> 0:12:56.900000
 You say, wait a second,
 Keith, you just told me.

0:12:56.900000 --> 0:12:59.600000
 We're not supposed to think
 about A, B, and C anymore.

0:12:59.600000 --> 0:13:02.700000
 All right, let's talk about that.

0:13:02.700000 --> 0:13:06.240000
 Because a lot of people come to me and
 they say, hey, I understand that

0:13:06.240000 --> 0:13:08.800000
 classless addressing is a
 thing of the dinosaurs.

0:13:08.800000 --> 0:13:12.340000
 That's been dead for decades, probably
 since before I was even born in

0:13:12.340000 --> 0:13:17.040000
 some cases. So why do I even have to
 learn about it in the first place?

0:13:17.040000 --> 0:13:19.060000
 Well, there's a variety
 of reasons.

0:13:19.060000 --> 0:13:24.920000
 Number one, if I told you, hey, go onto
 your laptop and give it this IP

0:13:24.920000 --> 0:13:30.080000
 address, 225.7.7.10.

0:13:30.080000 --> 0:13:33.920000
 All right, so trusting me, you go to
 your laptop and you try to put that

0:13:33.920000 --> 0:13:35.840000
 on and you get an error.

0:13:35.840000 --> 0:13:38.360000
 You come back all frustrate with half
 of your hair pulled out and you

0:13:38.360000 --> 0:13:41.460000
 say, Keith, I kept trying to put that
 IP address on there, and I kept

0:13:41.460000 --> 0:13:42.640000
 getting an error message.

0:13:42.640000 --> 0:13:44.340000
 What the heck is going on?

0:13:44.340000 --> 0:13:48.520000
 Well, if you didn't know about classless
 addresses, you wouldn't know

0:13:48.520000 --> 0:13:54.460000
 that this address here is
 in the class D space.

0:13:54.460000 --> 0:14:03.000000
 Because in binary, the number
 225 begins with 1, 1, 1, 0.

0:14:03.000000 --> 0:14:07.400000
 So that first octet
 looks like that.

0:14:07.400000 --> 0:14:08.280000
 Well, guess what?

0:14:08.280000 --> 0:14:11.800000
 Class D addresses, you can't
 put those on devices.

0:14:11.800000 --> 0:14:13.620000
 That's used for multicast.

0:14:13.620000 --> 0:14:16.000000
 That's used for a special
 application.

0:14:16.000000 --> 0:14:19.660000
 Well, if you didn't know what class
 D was, how would you know that?

0:14:19.660000 --> 0:14:23.600000
 You wouldn't. Another
 practical example.

0:14:23.600000 --> 0:14:28.420000
 As you get further into the world of
 networking, you're going to learn

0:14:28.420000 --> 0:14:30.880000
 something, and especially when you start
 getting into the world of routing

0:14:30.880000 --> 0:14:33.600000
 and how routers do their thing.

0:14:33.600000 --> 0:14:37.220000
 You'll learn something about
 route summarization.

0:14:37.220000 --> 0:14:40.440000
 Now, if what I'm about to say here goes
 completely over your head, don't

0:14:40.440000 --> 0:14:44.480000
 worry about it. It will make sense in
 a few weeks or months when you get

0:14:44.480000 --> 0:14:46.040000
 to the topic of routing.

0:14:46.040000 --> 0:14:47.560000
 But let's say here that
 we have a router.

0:14:47.560000 --> 0:14:50.100000
 Let's just call him router A.

0:14:50.100000 --> 0:14:52.780000
 And he's connected to router B.

0:14:52.780000 --> 0:14:57.100000
 Now, router A is learning about
 a whole bunch of networks.

0:14:57.100000 --> 0:15:02.180000
 Maybe he's learning about
 the 10.10.10.0 network.

0:15:02.180000 --> 0:15:09.020000
 He's learning about
 10.10.5.32 network.

0:15:09.020000 --> 0:15:11.360000
 And don't worry if you don't understand
 this nomenclature that I'm writing

0:15:11.360000 --> 0:15:13.500000
 down right here.

0:15:13.500000 --> 0:15:20.420000
 10.10.100.0. Now, the normal behavior
 of a routing protocol is that whatever

0:15:20.420000 --> 0:15:24.060000
 routes he learns, he just sends
 those routes onto his neighbor.

0:15:24.060000 --> 0:15:27.240000
 So he keeps a copy for himself so he
 knows where they are, and he sends

0:15:27.240000 --> 0:15:28.640000
 it onto his neighbor.

0:15:28.640000 --> 0:15:33.600000
 But in this case we could say, wait a
 second, router A isn't every single

0:15:33.600000 --> 0:15:37.540000
 route you're learning have
 something in common.

0:15:37.540000 --> 0:15:40.300000
 Don't they all begin with 10?

0:15:40.300000 --> 0:15:44.280000
 So on this interface is an example,
 we could turn on something called

0:15:44.280000 --> 0:15:52.180000
 route summarization, which basically
 gives the router the permission to

0:15:52.180000 --> 0:15:57.980000
 just send out one route that sort of
 collapses or contains all of these.

0:15:57.980000 --> 0:16:01.920000
 Now, here's the thing about
 route summarization.

0:16:01.920000 --> 0:16:05.300000
 In every single routing protocol, well
 not every routing protocol, but

0:16:05.300000 --> 0:16:08.760000
 most routing protocols, you
 have two ways to do it.

0:16:08.760000 --> 0:16:13.480000
 You have something called auto summarization,
 and you have something called

0:16:13.480000 --> 0:16:16.680000
 manual summarization.

0:16:16.680000 --> 0:16:20.340000
 Manual summarization means you as the
 human being have to take a look

0:16:20.340000 --> 0:16:23.400000
 at all these networks and you have to
 ask yourself, what do they all have

0:16:23.400000 --> 0:16:26.940000
 in common? Well, looking at this, I can
 pretty clearly see that all these

0:16:26.940000 --> 0:16:29.720000
 networks start with 10.10.

0:16:29.720000 --> 0:16:35.120000
 So if I was doing manual summarization,
 I would send this network over

0:16:35.120000 --> 0:16:40.420000
 to router B. Say, hey router B, any time
 you get a packet, we're the first

0:16:40.420000 --> 0:16:45.320000
 16 bits. So if a packet's coming in
 here or here or here, if the first

0:16:45.320000 --> 0:16:51.900000
 16 bits of that destination match this
 pattern, send it over to me, router

0:16:51.900000 --> 0:16:54.660000
 A, I know how to get it there.

0:16:54.660000 --> 0:16:59.280000
 So with manual summarization, it's like
 cedar that we just learned about.

0:16:59.280000 --> 0:17:02.740000
 With manual summarization, you get to
 choose where you want that dividing

0:17:02.740000 --> 0:17:05.360000
 line between network and host.

0:17:05.360000 --> 0:17:07.760000
 In this case, you'd say, all right, I've
 got all these networks I've learned

0:17:07.760000 --> 0:17:10.180000
 about. What do they
 all have in common?

0:17:10.180000 --> 0:17:12.360000
 All right, that's where
 my dividing line is.

0:17:12.360000 --> 0:17:17.380000
 I'll advertise one network to you
 that collapses them all together.

0:17:17.380000 --> 0:17:22.600000
 But if you're running auto summarization,
 most routing protocols when

0:17:22.600000 --> 0:17:25.060000
 you turn auto summarization,
 what do they do?

0:17:25.060000 --> 0:17:29.320000
 They shrink everything back
 to its classful boundary.

0:17:29.320000 --> 0:17:33.840000
 Now, if you didn't know what network
 classes were, you would have no idea

0:17:33.840000 --> 0:17:37.680000
 that 10 is a class A address.

0:17:37.680000 --> 0:17:39.300000
 It's in the class A range.

0:17:39.300000 --> 0:17:43.160000
 And now that you know it's in class
 A, you know that class A networks,

0:17:43.160000 --> 0:17:45.820000
 the first byte was the network.

0:17:45.820000 --> 0:17:49.000000
 The remaining bytes were host.

0:17:49.000000 --> 0:17:52.700000
 So in auto summarization, he's
 not going to send 10, 10.

0:17:52.700000 --> 0:17:56.300000
 He's just going to
 send 10, 0, 0, 0.

0:17:56.300000 --> 0:18:00.460000
 If you didn't know anything about classful
 addresses, you wouldn't understand

0:18:00.460000 --> 0:18:04.820000
 why auto summarization did
 something like that.

0:18:04.820000 --> 0:18:09.620000
 So, like I said, that might be above
 and beyond what you know at this

0:18:09.620000 --> 0:18:12.560000
 point, but hopefully it gives you a little
 bit of a clue as to, yes, Charlie

0:18:12.560000 --> 0:18:17.360000
 Brown, there is a reason, still to this
 day, to know something about classful

0:18:17.360000 --> 0:18:21.960000
 IP addresses. All
 right, so unicast.

0:18:21.960000 --> 0:18:24.800000
 You got a PC right here.

0:18:24.800000 --> 0:18:27.000000
 He wants to talk to
 a server right here.

0:18:27.000000 --> 0:18:30.940000
 Maybe they're separated by a router,
 so they're in two different networks.

0:18:30.940000 --> 0:18:35.080000
 So that means that this guy's going
 to have some source address.

0:18:35.080000 --> 0:18:37.900000
 This is going to be the destination address
 because it's going to go this

0:18:37.900000 --> 0:18:40.680000
 way. So unicast means one to one.

0:18:40.680000 --> 0:18:46.620000
 This one laptop is sending a packet
 to this one destination server.

0:18:46.620000 --> 0:18:50.560000
 Whatever his source address is, is
 going to be something in the class

0:18:50.560000 --> 0:18:53.120000
 A, B, or C space.

0:18:53.120000 --> 0:18:56.860000
 We don't know what it is, but it's going
 to be in that range somewhere.

0:18:56.860000 --> 0:18:59.820000
 And the destination, whatever his IP
 address is, will be in the class

0:18:59.820000 --> 0:19:03.320000
 A, B, or C space.

0:19:03.320000 --> 0:19:08.180000
 Now we also have multicast.

0:19:08.180000 --> 0:19:13.620000
 This is one to many communication and
 utilizes class D address space.

0:19:13.620000 --> 0:19:21.320000
 What this is referring to is, let's
 say that there's a server over here.

0:19:21.320000 --> 0:19:25.600000
 Now he's going to have some source address,
 which is in the unicast space.

0:19:25.600000 --> 0:19:27.760000
 Let's say he's 1.1.1.1.

0:19:27.760000 --> 0:19:31.040000
 All right, that's his IP address, kind
 of sloppy writing right there,

0:19:31.040000 --> 0:19:32.260000
 but you get the idea.

0:19:32.260000 --> 0:19:38.440000
 1.1.1.1. And let's say on this network
 segment, let's say these squares

0:19:38.440000 --> 0:19:41.420000
 here represent some PCs.

0:19:41.420000 --> 0:19:43.140000
 Oh Keith, you're so old.

0:19:43.140000 --> 0:19:44.520000
 Nobody has PCs anymore.

0:19:44.520000 --> 0:19:47.040000
 That's okay. Don't give
 me a hard time.

0:19:47.040000 --> 0:19:49.860000
 All right, so here
 we have some PCs.

0:19:49.860000 --> 0:19:53.160000
 They're very politically
 correct PCs.

0:19:53.160000 --> 0:19:56.480000
 All right, and each one of these
 guys has some IP address.

0:19:56.480000 --> 0:19:58.960000
 Let's just say, you know, let's
 just make some stuff up here.

0:19:58.960000 --> 0:20:00.680000
 Actually, it doesn't really matter
 what their IP address is.

0:20:00.680000 --> 0:20:02.180000
 That's irrelevant.

0:20:02.180000 --> 0:20:07.380000
 I'm just going to put some letters
 here, A, B, C, D, and E.

0:20:07.380000 --> 0:20:14.480000
 All right, now this guy, the server,
 he's putting a video on this wire

0:20:14.480000 --> 0:20:20.060000
 right here. Maybe as a matter of fact,
 it's a video that goes out 24 by

0:20:20.060000 --> 0:20:25.380000
 7. Maybe it's a feed
 from a camera.

0:20:25.380000 --> 0:20:27.260000
 Oh, let's make it something
 more interesting than that.

0:20:27.260000 --> 0:20:28.820000
 Maybe it's the news.

0:20:28.820000 --> 0:20:32.600000
 24 by 7, news cast,
 news all the time.

0:20:32.600000 --> 0:20:33.880000
 Get your pessimism here.

0:20:33.880000 --> 0:20:35.160000
 I'm sorry, I shouldn't
 have said that.

0:20:35.160000 --> 0:20:41.880000
 Anyway, the video's going out
 24 by 7, and here's the deal.

0:20:41.880000 --> 0:20:50.500000
 If, let's say PCA and PCE
 wanted to get that.

0:20:50.500000 --> 0:20:52.620000
 What if they want to watch that?

0:20:52.620000 --> 0:20:57.360000
 Well, if we sent this out as unicast,
 we'd have to have a stream of video

0:20:57.360000 --> 0:21:03.880000
 going directly to PCA's IP address,
 whatever it is, and a copy of that

0:21:03.880000 --> 0:21:07.940000
 stream going to PCE's IP address.

0:21:07.940000 --> 0:21:14.880000
 Not a big deal until we start having
 hundreds or thousands of people that

0:21:14.880000 --> 0:21:16.320000
 want to watch that video.

0:21:16.320000 --> 0:21:21.180000
 If I've got hundreds of people that
 want to watch that video feed, this

0:21:21.180000 --> 0:21:25.920000
 server's going to have a real hard
 time creating hundreds of copies of

0:21:25.920000 --> 0:21:29.320000
 these packets going to all these
 different hundreds of addresses.

0:21:29.320000 --> 0:21:31.160000
 That's not going to
 scale very well.

0:21:31.160000 --> 0:21:34.480000
 All right, well, what other
 alternative we have?

0:21:34.480000 --> 0:21:39.860000
 Well, we also have something, I actually
 probably should have had it before

0:21:39.860000 --> 0:21:42.280000
 multicast, but it's going to come up
 here in the slide which is called

0:21:42.280000 --> 0:21:49.920000
 broadcast. A broadcast packet is a packet
 that once it goes out, everybody

0:21:49.920000 --> 0:21:51.400000
 has to listen to it.

0:21:51.400000 --> 0:21:52.820000
 They don't have a choice.

0:21:52.820000 --> 0:21:57.200000
 Everybody has to listen to that
 packet no matter who they are.

0:21:57.200000 --> 0:21:59.840000
 Well, that's not really ideal
 in this situation either.

0:21:59.840000 --> 0:22:01.840000
 I mean, it's helpful
 in the server.

0:22:01.840000 --> 0:22:06.580000
 All he has to do is send out a single
 stream of packets, but the destination

0:22:06.580000 --> 0:22:11.000000
 address of those packets was broadcast,
 that means that all these PCs

0:22:11.000000 --> 0:22:15.360000
 would have to interrupt what they're
 doing to watch that broadcast.

0:22:15.360000 --> 0:22:19.360000
 And PCs, B, C, and D, they
 don't care about the news.

0:22:19.360000 --> 0:22:21.100000
 They're not watching
 that right now.

0:22:21.100000 --> 0:22:23.240000
 So broadcast not too useful.

0:22:23.240000 --> 0:22:27.420000
 So this is where we could use
 the concept of a multicast.

0:22:27.420000 --> 0:22:32.340000
 So here's how multicast works.

0:22:32.340000 --> 0:22:40.360000
 As the slide shows, multicast addresses
 are only formed in the source.

0:22:40.360000 --> 0:22:45.000000
 So if here's my packet, not the source,
 the destination, the source address

0:22:45.000000 --> 0:22:47.720000
 will be a unicast address.

0:22:47.720000 --> 0:22:51.020000
 The source address will be the address
 of whatever server is pumping out

0:22:51.020000 --> 0:22:54.880000
 this multicast video or
 audio or whatever it is.

0:22:54.880000 --> 0:22:57.980000
 It's the destination address
 that will be special.

0:22:57.980000 --> 0:23:02.360000
 The destination address will
 be a multicast address.

0:23:02.360000 --> 0:23:07.520000
 And because it's class D, that means
 it's going to be somewhere from 224

0:23:07.520000 --> 0:23:17.680000
.0.0.1, that is the smallest class D
 address you can have, up to 239.255

0:23:17.680000 --> 0:23:24.660000
.255. That is the largest
 class D address space.

0:23:24.660000 --> 0:23:30.040000
 So this right here is all class D and
 a multicast is going to go to that.

0:23:30.040000 --> 0:23:32.260000
 Well, how's that going to
 help these guys down here?

0:23:32.260000 --> 0:23:35.840000
 Well, let's say this video here, let's
 say the person who created this

0:23:35.840000 --> 0:23:38.940000
 video stream on the server, he decided
 that he wanted the destination

0:23:38.940000 --> 0:23:45.040000
 to go out to 227.777.

0:23:45.040000 --> 0:23:47.940000
 Here's the way this is work.

0:23:47.940000 --> 0:23:51.480000
 Now, each one of these PCs, remember,
 they've got their own unique address.

0:23:51.480000 --> 0:23:57.660000
 Maybe this guy is 1.1.1.2, maybe
 this guy here is 4.4.4.

0:23:57.660000 --> 0:24:03.380000
 You know, who knows what
 they are, 7.7.7.

0:24:03.380000 --> 0:24:09.520000
 So, the guy on PCA, he decides that
 he wants to take a break and watch

0:24:09.520000 --> 0:24:11.640000
 the multicast new stream.

0:24:11.640000 --> 0:24:13.120000
 So what does he do?

0:24:13.120000 --> 0:24:18.520000
 He sends a unicast packet to some
 directory server somewhere.

0:24:18.520000 --> 0:24:20.360000
 I'll just say DS.

0:24:20.360000 --> 0:24:23.260000
 Maybe he is 8888.

0:24:23.260000 --> 0:24:28.360000
 So somehow all these PCs have to know
 in advance that there's a directory

0:24:28.360000 --> 0:24:30.240000
 server out there at 8888.

0:24:30.240000 --> 0:24:32.780000
 And you go to him to find
 out what the shows are.

0:24:32.780000 --> 0:24:35.060000
 It's kind of like, you know, if you
 have direct TV and you pull up the

0:24:35.060000 --> 0:24:38.740000
 guide and the guide will show you, okay,
 go to this channel if you want

0:24:38.740000 --> 0:24:39.860000
 to watch this show.

0:24:39.860000 --> 0:24:42.040000
 Go to this channel if you want
 to watch this other show.

0:24:42.040000 --> 0:24:44.140000
 Same type of thing, this
 guy is the guide.

0:24:44.140000 --> 0:24:46.400000
 So we send a unicast
 packet to him.

0:24:46.400000 --> 0:24:51.340000
 So PCA, who is at 1.1.1.2, would send
 out a unicast packet going to 8888

0:24:51.340000 --> 0:24:54.400000
 and say, hey, what shows
 are available right now?

0:24:54.400000 --> 0:24:57.320000
 This guy would send a unicast packet
 back saying, hey, if you want to

0:24:57.320000 --> 0:25:03.540000
 watch the news, that's currently
 going out to 227.7.7.7.

0:25:03.540000 --> 0:25:09.420000
 So now what PCA does is his
 NIC card is reprogrammed.

0:25:09.420000 --> 0:25:13.880000
 Right now his NIC card is his network
 interface card is really only looking

0:25:13.880000 --> 0:25:15.940000
 for packets going to 1.1.1.2.

0:25:15.940000 --> 0:25:17.580000
 That's all he cares about.

0:25:17.580000 --> 0:25:22.700000
 Now we say, hey, NIC card, in addition
 to 1.1.1.2, if you ever see a packet

0:25:22.700000 --> 0:25:28.560000
 going to 227.7.7.7, I
 want to see that too.

0:25:28.560000 --> 0:25:31.980000
 Pick it up. Send it
 to my processor.

0:25:31.980000 --> 0:25:35.180000
 So right now there's a stream of packets
 going onto this wire going to

0:25:35.180000 --> 0:25:42.100000
 227.7.7.7. Then PCB, CD, and E are ignoring
 it because that's not their

0:25:42.100000 --> 0:25:45.860000
 address, but now PCA can
 pick it up and watch it.

0:25:45.860000 --> 0:25:50.300000
 Now maybe a few minutes later,
 PCE says, you know what?

0:25:50.300000 --> 0:25:52.300000
 I'd like to watch
 the news as well.

0:25:52.300000 --> 0:25:53.180000
 He does the same thing.

0:25:53.180000 --> 0:25:55.320000
 He sends a packet to
 the directory server.

0:25:55.320000 --> 0:25:59.800000
 He finds out that the news
 is going to 227.7.7.7.

0:25:59.800000 --> 0:26:05.840000
 So maybe his original address was 1
.1.1.5, but now he programs his NIC

0:26:05.840000 --> 0:26:07.420000
 card to also listen to the news.

0:26:07.420000 --> 0:26:10.480000
 He's going to 227.7.7.7.7.

0:26:10.480000 --> 0:26:14.780000
 And now he can get a copy
 of that packet as well.

0:26:14.780000 --> 0:26:19.960000
 This is why we call multicast 1 to
 many, because it's coming from one

0:26:19.960000 --> 0:26:26.540000
 multicast source, but any number of
 arbitrary destinations can view and

0:26:26.540000 --> 0:26:27.880000
 pick up this packet.

0:26:27.880000 --> 0:26:32.580000
 They just have to know in advance what
 the multicast destination address

0:26:32.580000 --> 0:26:37.480000
 is. Once they know that, they can program
 their NIC card to listen to

0:26:37.480000 --> 0:26:41.460000
 that. And then once they're done, if
 PCA says, okay, I'm done watching

0:26:41.460000 --> 0:26:43.500000
 the news, time for me
 to get back to work.

0:26:43.500000 --> 0:26:47.880000
 He can shut down his multicast application,
 and now he's no longer listening

0:26:47.880000 --> 0:26:52.280000
 to 227.7.7.7.7. So even though those
 packets might still be going on to

0:26:52.280000 --> 0:26:57.460000
 his wire, he's no longer going
 to pick them up and watch them.

0:26:57.460000 --> 0:27:01.960000
 So that's how multicast works, and the
 destinations always in this special

0:27:01.960000 --> 0:27:05.680000
 reserved range here of Class D.

0:27:05.680000 --> 0:27:11.460000
 And then the last thing, which I
 briefly mentioned, is broadcast.

0:27:11.460000 --> 0:27:16.820000
 This is one to all communications, and
 there are two flavors of broadcast.

0:27:16.820000 --> 0:27:20.600000
 There's general broadcasts
 and directed broadcasts.

0:27:20.600000 --> 0:27:23.560000
 First of all, let's start talking about
 the general broadcast, because

0:27:23.560000 --> 0:27:26.980000
 that's probably the one you're
 going to see the most often.

0:27:26.980000 --> 0:27:32.120000
 Anytime you see a packet with a destination
 address that matches this

0:27:32.120000 --> 0:27:39.360000
 pattern right here, that
 is a general broadcast.

0:27:39.360000 --> 0:27:45.000000
 That means, hey, everybody everywhere,
 you have to pay attention to this.

0:27:45.000000 --> 0:27:51.880000
 A common use of this would be, for
 example, whenever your laptop or PC

0:27:51.880000 --> 0:27:55.160000
 connects to a new network, like let's
 say you pick it up, carry it under

0:27:55.160000 --> 0:27:58.820000
 your arm, walk over to a conference
 room in the next building, plug it

0:27:58.820000 --> 0:28:00.500000
 into the network there.

0:28:00.500000 --> 0:28:03.660000
 Well, now your laptop's going to say,
 oh, I just got plugged into a new

0:28:03.660000 --> 0:28:06.640000
 network. My network interface
 card is receiving energy.

0:28:06.640000 --> 0:28:08.180000
 I'm on a new network.

0:28:08.180000 --> 0:28:10.840000
 First thing your laptop's going to
 do is he's going to say, I need an

0:28:10.840000 --> 0:28:15.700000
 IP address that's appropriate for the
 network I'm sitting on right now.

0:28:15.700000 --> 0:28:19.820000
 So your laptop is going to send out
 a special message called DHCP, the

0:28:19.820000 --> 0:28:21.940000
 dynamic host configuration
 protocol.

0:28:21.940000 --> 0:28:26.060000
 Your laptop's going to say, hey, is there
 a DHCP server out there somewhere

0:28:26.060000 --> 0:28:30.060000
 that can give me an address that's appropriate
 for where I am right now?

0:28:30.060000 --> 0:28:35.860000
 Well, your laptop has no idea if a DHCP
 server exists that can give you

0:28:35.860000 --> 0:28:39.160000
 that information, or if he
 does exist where he is.

0:28:39.160000 --> 0:28:41.760000
 So this is where broadcast
 would be used.

0:28:41.760000 --> 0:28:46.880000
 Your DHCP packet you send out, the destination
 address would be this pattern

0:28:46.880000 --> 0:28:49.620000
 right here, which is saying,
 hey, everybody everywhere.

0:28:49.620000 --> 0:28:53.740000
 You need to stop what you're doing
 and look at this because I might be

0:28:53.740000 --> 0:28:59.020000
 talking to you. Now, directed broadcast,
 you're not going to see that

0:28:59.020000 --> 0:29:02.280000
 as often. That would be
 something like this.

0:29:02.280000 --> 0:29:06.100000
 Let's say that you already knew
 what your IP address was.

0:29:06.100000 --> 0:29:09.880000
 All right, let's say your
 IP address was this.

0:29:09.880000 --> 0:29:13.800000
 Now, we know that that's
 your IP address.

0:29:13.800000 --> 0:29:16.240000
 You got to know what your networking
 bits are and what your host bits

0:29:16.240000 --> 0:29:29.820000
 are. Now, remember, the way that your
 laptop or PC views the subnet mask

0:29:29.820000 --> 0:29:38.800000
 is in binary. So this here translates
 to 1111 1111 1111 and then a whole

0:29:38.800000 --> 0:29:40.340000
 string of zeros.

0:29:40.340000 --> 0:29:44.560000
 That's what this value stands for.


0:29:44.560000 --> 0:29:47.500000
 So that means when you compare it against
 your IP address, you can see

0:29:47.500000 --> 0:29:47.500000
 that the IP address is in binary.

0:29:47.500000 --> 0:29:51.280000
 The IP address that your network
 is the 1.1 network.

0:29:51.280000 --> 0:29:55.840000
 Me as a host, I am 1.1 as a host, but
 there might be somebody else on

0:29:55.840000 --> 0:30:00.260000
 my exact same network
 who is 1.1.55.9.

0:30:00.260000 --> 0:30:04.360000
 And somebody else who's 1.1.32.7.

0:30:04.360000 --> 0:30:08.200000
 As long as we all begin with 1.1, we
 know based on our subnet mask that

0:30:08.200000 --> 0:30:09.740000
 we're on the same network.

0:30:09.740000 --> 0:30:14.080000
 Now, what if I want to send out a
 broadcast, but here's the catch.

0:30:14.080000 --> 0:30:17.360000
 I don't want to send it to necessarily
 everybody in the world on every

0:30:17.360000 --> 0:30:22.500000
 single network. I just want to direct
 it to people on my network.

0:30:22.500000 --> 0:30:24.700000
 This is what's called
 a directed broadcast.

0:30:24.700000 --> 0:30:28.260000
 A broadcast that says, hey, this broadcast
 is only meant for people in

0:30:28.260000 --> 0:30:31.760000
 this network. Well, here's
 how I would do it.

0:30:31.760000 --> 0:30:39.600000
 If my network is 1.1, I would
 set my host bits to 1.

0:30:39.600000 --> 0:30:43.100000
 So remember, here's how your computer
 sees your IP address.

0:30:43.100000 --> 0:30:45.960000
 1, 2, 3, 4, 5, 6, 7, 8.

0:30:45.960000 --> 0:30:47.900000
 There's my first byte, which is 1.


0:30:47.900000 --> 0:30:51.160000
 1, 2, 3, 4, 5, 6, 7, 8.

0:30:51.160000 --> 0:30:54.360000
 And then after that says everything,
 so it says, that is my networking

0:30:54.360000 --> 0:30:57.800000
 bits based on my mask.

0:30:57.800000 --> 0:31:01.540000
 And everything else after
 that are host bits.

0:31:01.540000 --> 0:31:05.560000
 Well, in a directed broadcast, you keep
 the networking bits to whatever

0:31:05.560000 --> 0:31:11.340000
 they are, but you set your host bits
 to all ones, which in this case would

0:31:11.340000 --> 0:31:15.320000
 translate to 255.255.

0:31:15.320000 --> 0:31:19.980000
 So this would be a
 directed broadcast.

0:31:19.980000 --> 0:31:23.140000
 Everybody in the 1.1 network would have
 to get it because it's not going

0:31:23.140000 --> 0:31:25.420000
 to any particular host.

0:31:25.420000 --> 0:31:29.880000
 No host will ever have the
 host bits set to all ones.

0:31:29.880000 --> 0:31:34.000000
 That's illegal. So when you look at
 your host bits here, if your host

0:31:34.000000 --> 0:31:40.200000
 bits are all zeros, or if they're all
 ones, that means something special.

0:31:40.200000 --> 0:31:42.060000
 That is not a host.

0:31:42.060000 --> 0:31:45.680000
 Any IP address where the host bits are
 all zeros are all ones that will

0:31:45.680000 --> 0:31:49.380000
 never be assigned to any laptop,
 server, PC, whatever.

0:31:49.380000 --> 0:31:57.240000
 In this particular case, if they're all
 ones, that is the directed broadcast.

0:31:57.240000 --> 0:32:01.960000
 So that concludes this video on IP
 addresses and how to differentiate

0:32:01.960000 --> 0:32:04.740000
 the network bits from
 the host bits.

0:32:04.740000 --> 0:32:06.020000
 Thank you so much for watching.

