WEBVTT

0:00:08.280000 --> 0:00:13.360000
 Just a review. We know
 what a subnet mask is.

0:00:13.360000 --> 0:00:15.400000
 It's a comparison tool.

0:00:15.400000 --> 0:00:23.080000
 Now it's for us as humans, it's nice when
 we see an IP address and a subnet

0:00:23.080000 --> 0:00:29.960000
 mask and the subnet mask falls in a
 nice boundary of a byte like 255.000

0:00:29.960000 --> 0:00:37.340000
 or 255.255.00. That's real easy for us using
 our eyeballs to do that comparison

0:00:37.340000 --> 0:00:42.440000
 and say, oh okay clearly this octet and
 this octet belong to the network,

0:00:42.440000 --> 0:00:44.880000
 everything else is host bits.

0:00:44.880000 --> 0:00:47.600000
 Well I've been trying to show you some
 of these quiz questions here is

0:00:47.600000 --> 0:00:51.720000
 the subnet mask gives you the ability
 to draw that dividing line anywhere

0:00:51.720000 --> 0:00:54.580000
 in that 32-bit IP address.

0:00:54.580000 --> 0:00:58.980000
 It doesn't have to fall right
 at the end of a byte.

0:00:58.980000 --> 0:01:06.000000
 So for example, in this particular
 case it does fall right at the end

0:01:06.000000 --> 0:01:10.400000
 of a byte, right at right after the
 second byte our subnet mask ends and

0:01:10.400000 --> 0:01:16.520000
 so it says okay the first two bytes with
 a slash 16 belong to the network.

0:01:16.520000 --> 0:01:19.940000
 Another one where it falls right at
 the end so in this case with a slash

0:01:19.940000 --> 0:01:27.280000
 24 that says the first three entire bytes
 belong to the network, no problem.

0:01:27.280000 --> 0:01:31.300000
 But you could easily do
 it like this, slash 28.

0:01:31.300000 --> 0:01:36.040000
 Where you say okay the subnet mask extends
 all the way into the last octet,

0:01:36.040000 --> 0:01:41.920000
 four bits of the last octet
 belong to the group.

0:01:41.920000 --> 0:01:46.180000
 So in that last example, example number
 three there, we've only got four

0:01:46.180000 --> 0:01:47.220000
 bits left for host.

0:01:47.220000 --> 0:01:51.160000
 So let me ask you some questions
 about what you see right here.

0:01:51.160000 --> 0:01:56.380000
 Question number one, what was the original
 classful network before any

0:01:56.380000 --> 0:01:58.580000
 subnet masks were applied?

0:01:58.580000 --> 0:02:01.660000
 So forget about the slash
 16 slash 24 and slash 28.

0:02:01.660000 --> 0:02:05.160000
 If we were looking at this purely from
 a classful network perspective,

0:02:05.160000 --> 0:02:07.280000
 what would the classful
 network have been?

0:02:07.280000 --> 0:02:10.260000
 Go ahead and someone type that into
 the question feed there and answer

0:02:10.260000 --> 0:02:14.460000
 that for me. Does anybody know what
 the original classful network was?

0:02:14.460000 --> 0:02:20.420000
 Well the original classful network
 was the one network, right?

0:02:20.420000 --> 0:02:25.040000
 With the first bit being a zero, that
 was a class A, so we only looked

0:02:25.040000 --> 0:02:29.400000
 at the first byte, the first byte, if
 we translate that back to decimals

0:02:29.400000 --> 0:02:33.580000
 the number one, so that was
 the one zero zero network.

0:02:33.580000 --> 0:02:41.600000
 Next question. In all three of these
 examples, what is the network address

0:02:41.600000 --> 0:02:45.100000
 now that we've got slash 16,
 slash 24 and slash 28.

0:02:45.100000 --> 0:02:49.080000
 So in this first example here, example
 number one, given the subnet mask,

0:02:49.080000 --> 0:02:53.340000
 we're no longer doing classful, what's
 the new network address based on

0:02:53.340000 --> 0:02:54.760000
 what you see right here?

0:02:54.760000 --> 0:02:59.000000
 Well hopefully it's pretty easy, you
 just count up the red bits, the first

0:02:59.000000 --> 0:03:03.700000
 byte is one, the second byte is the
 number three, so this is the one dot

0:03:03.700000 --> 0:03:08.860000
 three network. And the second example,
 our network address is now one

0:03:08.860000 --> 0:03:12.380000
 dot three dot one ninety two.

0:03:12.380000 --> 0:03:18.720000
 And the third example, the network address
 is one dot three dot one ninety

0:03:18.720000 --> 0:03:25.260000
 two dot one hundred and twelve, that one's
 a little bit tougher, one hundred

0:03:25.260000 --> 0:03:28.180000
 and twelve is the fourth octet.

0:03:28.180000 --> 0:03:32.440000
 Of these three examples here with these
 three different subnet masks,

0:03:32.440000 --> 0:03:37.120000
 which one provides for the
 greatest quantity of hosts?

0:03:37.120000 --> 0:03:44.200000
 Well hopefully you very quickly said
 example number one, because example

0:03:44.200000 --> 0:03:49.020000
 number one's got a whole lot of host
 bits, the other two examples don't

0:03:49.020000 --> 0:04:00.980000
 have as many. The network of one zero
 zero zero, which of these subnet

0:04:00.980000 --> 0:04:06.080000
 masks would provide for the greatest
 quantity of subnets?

0:04:06.080000 --> 0:04:08.460000
 In other words, which of these subnet
 masks would allow us to take that

0:04:08.460000 --> 0:04:13.360000
 original network of one zero zero zero
 and carve it up into the most quantity

0:04:13.360000 --> 0:04:16.900000
 of subnets that we could give
 us the most variation?

0:04:16.900000 --> 0:04:20.980000
 Well hopefully you said
 example number three.

0:04:20.980000 --> 0:04:26.100000
 With example number three, I can't touch
 my original network of one, but

0:04:26.100000 --> 0:04:32.060000
 with a slash twenty eight, that means
 I've got eight sixteen twenty bits

0:04:32.060000 --> 0:04:38.020000
 of subnetting. That gives me two to
 the power of twenty combinations I

0:04:38.020000 --> 0:04:43.500000
 can come up with, tens of thousands
 of hundreds of thousands of networks

0:04:43.500000 --> 0:04:51.060000
 I can come up with.

0:04:51.060000 --> 0:04:53.960000
 So why do we subnet?

0:04:53.960000 --> 0:05:02.600000
 So we can divide a single allocated
 network into multiple subnetworks.

0:05:02.600000 --> 0:05:05.900000
 That's the whole reason behind it.


0:05:05.900000 --> 0:05:09.340000
 Minor loss of host
 space available.

0:05:09.340000 --> 0:05:12.400000
 So here's a practical example.

0:05:12.400000 --> 0:05:15.700000
 Imagine if you lease a network from
 your ISP for one hundred dollars a

0:05:15.700000 --> 0:05:21.220000
 month. The building here we
 see requires four networks.

0:05:21.220000 --> 0:05:28.180000
 If we used classful addressing, that right
 there would cost us four hundred

0:05:28.180000 --> 0:05:33.320000
 dollars a month because we had to purchase
 or lease four unique networks.

0:05:33.320000 --> 0:05:39.960000
 With subnetting, I can take just one
 classful network, subnet it, I'm

0:05:39.960000 --> 0:05:41.000000
 only paying a hundred
 dollars a month.

0:05:41.000000 --> 0:05:45.980000
 I'm only paying one fee for my twenty
 zero zero zero from my ISP, but

0:05:45.980000 --> 0:05:49.580000
 by extending those bits out with a
 subnet mask, I've now given myself

0:05:49.580000 --> 0:05:52.980000
 four unique networks, but I'm
 only paying for one of them.

0:05:52.980000 --> 0:05:58.960000
 One of the key points I want you to take
 away from this is that as I take

0:05:58.960000 --> 0:06:02.540000
 my original network and I say, okay,
 I'm not going to take some of my

0:06:02.540000 --> 0:06:05.300000
 host bits and add them
 to that network.

0:06:05.300000 --> 0:06:07.800000
 Give me a little bit of room
 to play and have variation.

0:06:07.800000 --> 0:06:12.180000
 Well, the more host bits you steal,
 you'll see that term a lot, stealing

0:06:12.180000 --> 0:06:15.740000
 bits, which means you're taking your
 host bits and you're stealing them

0:06:15.740000 --> 0:06:18.760000
 for networking bits, you're converting
 them into subnet bits.

0:06:18.760000 --> 0:06:23.320000
 The more subnet bits I have, there's
 pros and cons to that.

0:06:23.320000 --> 0:06:26.920000
 The more subnet bits I have available
 to me, the more networks I can come

0:06:26.920000 --> 0:06:33.020000
 up with. But the more subnet bits
 I have, the less host bits I have.

0:06:33.020000 --> 0:06:37.040000
 And the fewer host bits I have, that
 means that each subnet can't have

0:06:37.040000 --> 0:06:39.040000
 as many hosts anymore.

0:06:39.040000 --> 0:06:41.500000
 The subnets are getting
 smaller and smaller.

0:06:41.500000 --> 0:06:46.120000
 So here's an example of that.

0:06:46.120000 --> 0:06:51.700000
 So I got this class B from my ISP, one
 eighty dot one, that's the network.

0:06:51.700000 --> 0:06:59.380000
 We know that those original sixteen
 bits are untouchable.

0:06:59.380000 --> 0:07:01.460000
 Can't touch those bits.

0:07:01.460000 --> 0:07:04.560000
 So we ask ourselves, how
 many host bits do I have?

0:07:04.560000 --> 0:07:07.300000
 Well, in this case,
 I've got sixteen.

0:07:07.300000 --> 0:07:11.500000
 Sixteen bits I can play with on
 the back end of this address.

0:07:11.500000 --> 0:07:17.220000
 For every host bit that you convert into
 a subnet bit, you've just gained

0:07:17.220000 --> 0:07:23.420000
 two additional networks,
 two additional networks.

0:07:23.420000 --> 0:07:32.720000
 For example, if this is what I was given
 from my service provider, let's

0:07:32.720000 --> 0:07:39.480000
 say one zero, two three four five six
 seven eight, one two three four

0:07:39.480000 --> 0:07:40.460000
 five six seven eight.

0:07:40.460000 --> 0:07:50.420000
 So that's what I'm given from
 my ISP and I can't touch that.

0:07:50.420000 --> 0:07:54.680000
 Okay, there's my remaining
 sixteen bits of host bits.

0:07:54.680000 --> 0:07:57.700000
 Well, if I say, well, here's
 what I'm going to do.

0:07:57.700000 --> 0:08:03.360000
 I'm going to take this bit right here
 and add it to my networking bits.

0:08:03.360000 --> 0:08:08.280000
 I'm going to say, well, my group, my broadcast
 domain is the first seventeen

0:08:08.280000 --> 0:08:13.340000
 bits. Well, I know I can't touch
 this original pattern of sixteen.

0:08:13.340000 --> 0:08:15.580000
 That was purchased from my ISP.

0:08:15.580000 --> 0:08:17.120000
 But what can I do?

0:08:17.120000 --> 0:08:22.240000
 I can say, well, I've got one network
 that's one twenty nine dot one and

0:08:22.240000 --> 0:08:25.580000
 then put a zero right here.

0:08:25.580000 --> 0:08:29.420000
 My only other option is to
 put a one right there.

0:08:29.420000 --> 0:08:33.300000
 I've just now taken the one network I
 got from my ISP and subdivided into

0:08:33.300000 --> 0:08:38.580000
 two portions. One broadcast domain is
 a seventeen bit group number ending

0:08:38.580000 --> 0:08:43.680000
 with zero. The other broadcast domain
 is a seventeen bit number beginning

0:08:43.680000 --> 0:08:46.740000
 ending with a one.

0:08:46.740000 --> 0:08:51.840000
 You can see if I move it, let's
 say I move that line.

0:08:51.840000 --> 0:08:57.040000
 I say, well, I'm actually going
 to now take two of my host bits.

0:08:57.040000 --> 0:09:00.460000
 Well now what can I have?

0:09:00.460000 --> 0:09:04.080000
 Well, I can have one broadcast domain
 that ends with zero zero.

0:09:04.080000 --> 0:09:06.820000
 Another one that ends
 with zero one.

0:09:06.820000 --> 0:09:09.120000
 Another one that ends
 with one zero.

0:09:09.120000 --> 0:09:12.220000
 Another one that ends
 with one one.

0:09:12.220000 --> 0:09:19.880000
 So with two bits, I've now just
 given myself four combinations.

0:09:19.880000 --> 0:09:24.400000
 So what you're going to see here is
 this basically boils down to this

0:09:24.400000 --> 0:09:32.100000
 nice formula. Two to the power of subnetting
 or two to the power of N

0:09:32.100000 --> 0:09:38.160000
 gives you your quantity
 of subnets.

0:09:38.160000 --> 0:09:44.580000
 In other words, let's go
 back to my example here.

0:09:44.580000 --> 0:09:50.680000
 I'm given this original
 network of sixteen bits.

0:09:50.680000 --> 0:10:02.220000
 And I say, well, I need, let's
 say, eight networks.

0:10:02.220000 --> 0:10:16.780000
 Well if I use that formula, two to
 the power of stolen bits or two to

0:10:16.780000 --> 0:10:23.480000
 the power of subnetting
 bits, so now I solve it.

0:10:23.480000 --> 0:10:30.000000
 I say two to the power of SN subnetting
 bits is going to be greater than

0:10:30.000000 --> 0:10:34.660000
 or equal to eight because
 I need eight networks.

0:10:34.660000 --> 0:10:40.540000
 So you say, oh, well, okay, that
 would be the number three.

0:10:40.540000 --> 0:10:46.740000
 If I have two to the power of three,
 if I steal three bits, that will

0:10:46.740000 --> 0:10:50.220000
 actually give me eight combinations
 of numbers.

0:10:50.220000 --> 0:10:57.500000
 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, all
 the way up to one, one, one, one,

0:10:57.500000 --> 0:11:00.060000
 eight possible combinations.

0:11:00.060000 --> 0:11:05.300000
 So you might get questions like that
 on your CCNA or even in real life.

0:11:05.300000 --> 0:11:10.500000
 You're given some base network and you're
 told, okay, well, you need fifteen

0:11:10.500000 --> 0:11:12.280000
 networks or you need
 thirty networks.

0:11:12.280000 --> 0:11:17.200000
 How many host bits do you need to repurpose
 or reconvert into subnetting

0:11:17.200000 --> 0:11:21.280000
 bits to give you enough variation for
 the fifteen networks you need or

0:11:21.280000 --> 0:11:23.160000
 the twenty networks that you need?


0:11:23.160000 --> 0:11:32.020000
 Based on that, let's do some, oh, before
 we do another quiz, one other

0:11:32.020000 --> 0:11:34.920000
 key thing here, one
 other key thing.

0:11:34.920000 --> 0:11:36.880000
 Let's go back to this
 for a moment.

0:11:36.880000 --> 0:11:40.800000
 In my example, I said, well, I
 need to have eight networks.

0:11:40.800000 --> 0:11:45.140000
 You say, oh, well, okay, well, two of
 the power of three works, but why

0:11:45.140000 --> 0:11:49.520000
 don't I steal this many?

0:11:49.520000 --> 0:11:51.220000
 That looks good.

0:11:51.220000 --> 0:11:55.620000
 One I steal eleven bits, because two
 of the power of eleven is going to

0:11:55.620000 --> 0:11:57.820000
 give me far more than eight.

0:11:57.820000 --> 0:12:00.100000
 Yeah, but it will give me
 the eight you need, right?

0:12:00.100000 --> 0:12:03.480000
 Why not just use eight networking
 bits, subnet bits?

0:12:03.480000 --> 0:12:04.060000
 Well, here's the thing.

0:12:04.060000 --> 0:12:08.400000
 Remember, the further you push this
 line to the right, the more bits you

0:12:08.400000 --> 0:12:13.200000
 steal, the less host space
 you have available.

0:12:13.200000 --> 0:12:17.780000
 If I put my line way out here, my broadcast
 means not going to be able

0:12:17.780000 --> 0:12:21.760000
 to have very many laptops and PCs and
 printers in it, because I don't

0:12:21.760000 --> 0:12:26.040000
 have very many addresses
 left for host addresses.

0:12:26.040000 --> 0:12:29.240000
 So when you're doing subnetting in this
 way that we're doing right here,

0:12:29.240000 --> 0:12:37.000000
 the idea is push your line to the right,
 not as far as you can go, but

0:12:37.000000 --> 0:12:38.360000
 as minimal as you can go.

0:12:38.360000 --> 0:12:42.240000
 In other words, you say, okay, if I push
 it just one, will that be enough?

0:12:42.240000 --> 0:12:45.780000
 Ah, not enough. If I push it two
 to the right, is that enough?

0:12:45.780000 --> 0:12:49.860000
 Ah, not enough. Well, if I push it three
 to the right, that's just barely

0:12:49.860000 --> 0:12:51.760000
 going to give me what I need.

0:12:51.760000 --> 0:12:53.340000
 That's where you stop.

0:12:53.340000 --> 0:12:56.680000
 Where the number you come up with here
 is just barely what you're looking

0:12:56.680000 --> 0:13:00.040000
 for, but it just fits what
 you're looking for.

0:13:00.040000 --> 0:13:03.460000
 Sure, you could keep pushing it to
 the right if you wanted to, but now

0:13:03.460000 --> 0:13:08.800000
 you're sacrificing host space.

0:13:08.800000 --> 0:13:14.220000
 So let's do some examples of this.


0:13:14.220000 --> 0:13:21.060000
 So you are least the following network
 from your ISP, the 45 network.

0:13:21.060000 --> 0:13:27.360000
 If you convert the first three host
 bits into subnetting bits, how many

0:13:27.360000 --> 0:13:31.740000
 total subnets will
 you have available?

0:13:31.740000 --> 0:13:34.000000
 Okay, time's up.

0:13:34.000000 --> 0:13:38.140000
 If we use our formula of two to the
 power of subnetting bits, gives us

0:13:38.140000 --> 0:13:42.740000
 our total quantity of subnets, well,
 if we steal three bits, that's two

0:13:42.740000 --> 0:13:48.640000
 to the power of three, which
 gives us the number eight.

0:13:48.640000 --> 0:13:57.880000
 Robert, I see your question there.


0:13:57.880000 --> 0:14:04.180000
 When stealing start stealing point, is
 it connected to the classical network?

0:14:04.180000 --> 0:14:12.440000
 It's... So the question is, where do
 you start stealing the bits from?

0:14:12.440000 --> 0:14:15.760000
 You have to ask yourself, okay,
 what was I originally given?

0:14:15.760000 --> 0:14:19.660000
 What was I given from my service provider
 or from my regional internet

0:14:19.660000 --> 0:14:25.380000
 registry? Of my 32-bit number that
 they gave me, what amount of those

0:14:25.380000 --> 0:14:30.600000
 bits do they consider untouchable
 as the networking portion?

0:14:30.600000 --> 0:14:34.680000
 Now they may have given you a classical
 network or they may not.

0:14:34.680000 --> 0:14:38.280000
 For example, your regional internet
 registry or your service provider

0:14:38.280000 --> 0:14:48.920000
 could say, okay, we're giving
 you this, 140.55.64.0.

0:14:48.920000 --> 0:14:56.240000
 Slash 18. So what that means is, from
 the service provider's perspective,

0:14:56.240000 --> 0:15:00.520000
 I am not allowed to touch
 the first 18 bits.

0:15:00.520000 --> 0:15:02.660000
 That is not a classical mask.

0:15:02.660000 --> 0:15:07.260000
 A classical network would be a slash
 16 because 140 is a class B address.

0:15:07.260000 --> 0:15:11.340000
 But here, the service provider
 is giving me a slash 18.

0:15:11.340000 --> 0:15:15.820000
 So that means if I'm going to take that
 one network and subdivide it into

0:15:15.820000 --> 0:15:19.600000
 subnets, I'm going to have
 to go beyond slash 18.

0:15:19.600000 --> 0:15:22.860000
 So in this particular case of a
 slash 18, let me ask you this.

0:15:22.860000 --> 0:15:27.320000
 If they're giving me a slash 18, how
 many host bits do I have available

0:15:27.320000 --> 0:15:31.380000
 from this one network that I just purchased
 from my service provider?

0:15:31.380000 --> 0:15:35.600000
 How many host bits are left?

0:15:35.600000 --> 0:15:38.880000
 I've got 14 host bits left, right?


0:15:38.880000 --> 0:15:42.020000
 I've got 14 host bits because my service
 provider is saying, look, as

0:15:42.020000 --> 0:15:46.460000
 far as we're concerned, the first eight
 bits here are networking bits,

0:15:46.460000 --> 0:15:50.360000
 the first eight bits here are networking
 bits, and the first two bits

0:15:50.360000 --> 0:15:52.700000
 here are networking bits.

0:15:52.700000 --> 0:16:01.600000
 So that means of the third octet, I've
 got six host bits left, and then

0:16:01.600000 --> 0:16:06.060000
 of the fourth octet, I've
 got eight host bits left.

0:16:06.060000 --> 0:16:12.620000
 So I've got 14 host
 bits available.

0:16:12.620000 --> 0:16:13.600000
 One, two, three.

0:16:13.600000 --> 0:16:18.600000
 So what this is showing me in this
 particular case is one, two, three,

0:16:18.600000 --> 0:16:21.180000
 four, five, six, seven, eight, one,
 two, three, four, five, six, seven,

0:16:21.180000 --> 0:16:25.940000
 eight, one, two, so
 I can't touch those.

0:16:25.940000 --> 0:16:28.720000
 So this is what they've
 given me right here.

0:16:28.720000 --> 0:16:34.180000
 So I'll just say this
 is untouchable.

0:16:34.180000 --> 0:16:38.120000
 So now what's left over?

0:16:38.120000 --> 0:16:44.240000
 One, two, three, four, five, six, one,
 two, three, four, five, six, seven,

0:16:44.240000 --> 0:16:47.480000
 eight. So now I'm going to start
 stealing from right here.

0:16:47.480000 --> 0:16:50.960000
 If I'm going to start creating my subnets,
 I have to start from the right

0:16:50.960000 --> 0:16:57.240000
 of this line. So my subnets will be
 a slash 19, slash 20, slash 21, but

0:16:57.240000 --> 0:17:00.580000
 I can't go anything less than slash 18
 because slash 18 is what they gave

0:17:00.580000 --> 0:17:07.120000
 me. And yes, Robert, that number that
 you just did, that this right here,

0:17:07.120000 --> 0:17:11.100000
 I'll just put it right there, that's how
 you determine your host requirements.

0:17:11.100000 --> 0:17:14.700000
 That's actually the next slide.

0:17:14.700000 --> 0:17:18.380000
 So right now we've just been focusing
 in on how many bits do I need to

0:17:18.380000 --> 0:17:22.940000
 steal to come up with a number
 of subnets that I need.

0:17:22.940000 --> 0:17:27.400000
 Here's another one.

0:17:27.400000 --> 0:17:31.360000
 You are leased this network
 from your service provider.

0:17:31.360000 --> 0:17:35.580000
 If you convert the first six host bits
 into subnetting bits, how many

0:17:35.580000 --> 0:17:39.160000
 total subnets will
 you have available?

0:17:39.160000 --> 0:17:48.880000
 And if we use that same formula, two to
 the power of six gives me 64 subnets

0:17:48.880000 --> 0:17:52.360000
 available. That's right,
 two to the power of six.

0:17:52.360000 --> 0:17:58.960000
 Now let's take it up a notch, make
 it a little bit more complicated.

0:17:58.960000 --> 0:18:04.300000
 You are leased the following network
 from your service provider.

0:18:04.300000 --> 0:18:09.720000
 If you convert the first three host
 bits into subnetting bits, what will

0:18:09.720000 --> 0:18:14.460000
 be the subnet address
 of the fourth subnet?

0:18:14.460000 --> 0:18:19.980000
 Some of you may have been able to work
 this one through, some of you didn't.

0:18:19.980000 --> 0:18:24.560000
 Let's go ahead and look at
 the logic behind this.

0:18:24.560000 --> 0:18:26.620000
 Okay, so we are starting with 45.

0:18:26.620000 --> 0:18:29.620000
 I cannot touch those
 first eight bits.

0:18:29.620000 --> 0:18:33.240000
 And we are saying I am going to be
 subnetting my next three bits.

0:18:33.240000 --> 0:18:36.940000
 That gives me these various
 combinations.

0:18:36.940000 --> 0:18:41.040000
 The fourth subnet, well the first one
 is 000 and the next one is 001.

0:18:41.040000 --> 0:18:46.960000
 So the fourth combination
 I can come up with is 011.

0:18:46.960000 --> 0:18:53.460000
 So if I take all of my remaining host
 bits and convert them into zeros,

0:18:53.460000 --> 0:19:06.480000
 I get that. And so my fourth subnet
 is the 45.96.00 network with a slash

0:19:06.480000 --> 0:19:13.100000
 11 mask. Start out is slash eight and
 then I added three bits to it making

0:19:13.100000 --> 0:19:16.180000
 it into a slash 11.

0:19:16.180000 --> 0:19:18.740000
 So another one of these.

0:19:18.740000 --> 0:19:23.740000
 You are leased the following
 network, 199.00 slash 24.

0:19:23.740000 --> 0:19:28.040000
 From the single network you need
 to create seven subnets.

0:19:28.040000 --> 0:19:32.400000
 What will be your new subnet mask?


0:19:32.400000 --> 0:19:43.040000
 And the correct answer
 here was 255.254.

0:19:43.040000 --> 0:19:51.880000
 Why is that? Well we need
 to create seven subnets.

0:19:51.880000 --> 0:19:58.480000
 So we know two to the power of our subnetting
 bits must be greater than

0:19:58.480000 --> 0:20:01.380000
 or equal to seven.

0:20:01.380000 --> 0:20:09.240000
 So if we do two to the power of three,
 that gives us eight subnets.

0:20:09.240000 --> 0:20:12.100000
 So three is the minimum
 we can steal.

0:20:12.100000 --> 0:20:19.260000
 So if we start out with a slash 24
 and we add three more bits to that,

0:20:19.260000 --> 0:20:23.900000
 that gives us a slash 27.

0:20:23.900000 --> 0:20:30.340000
 Slash 27 means all eight bits of the
 first octet, all eight bits of the

0:20:30.340000 --> 0:20:37.500000
 second, all eight bits of the third
 and three bits, one one one, three

0:20:37.500000 --> 0:20:40.760000
 bits of the fourth octet.

0:20:40.760000 --> 0:20:43.580000
 That is our subnetting bits.

0:20:43.580000 --> 0:20:50.320000
 So that would be our
 new subnet mask.

0:20:50.320000 --> 0:21:08.240000
 Do one more. And then
 we'll take a break.

0:21:08.240000 --> 0:21:11.140000
 So we'll just remember the first
 19 bits are untouchable.

0:21:11.140000 --> 0:21:12.780000
 That's how you need
 to look at that.

0:21:12.780000 --> 0:21:17.740000
 From the single network you
 need to create 58 subnets.

0:21:17.740000 --> 0:21:21.500000
 What will be your new subnet mask?


0:21:21.500000 --> 0:21:28.960000
 Times up. There's your
 new subnet mask.

0:21:28.960000 --> 0:21:30.500000
 How did you come up with that?

0:21:30.500000 --> 0:21:32.400000
 How did we come up with that?

0:21:32.400000 --> 0:21:33.940000
 So here's how I do this.

0:21:33.940000 --> 0:21:35.520000
 Well, 58 subnets.

0:21:35.520000 --> 0:21:43.540000
 Let's see. Two to the power of one
 is two, four, eight, 16, 32, almost

0:21:43.540000 --> 0:21:49.800000
 there, 64. So I need
 to steal six bits.

0:21:49.800000 --> 0:21:53.540000
 That'll give me up to 64 subnets.

0:21:53.540000 --> 0:21:58.340000
 So I need to add six bits to this.


0:21:58.340000 --> 0:22:07.240000
 So 19 plus six is going
 to be 25 or a slash 25.

0:22:07.240000 --> 0:22:16.080000
 So that means here's my 24 and
 128 gives me my 25th bit.

0:22:16.080000 --> 0:22:17.220000
 So that's how you got that.

