Hi David, I am very busy lately so I missed your question.

Let me check if I got it right. You just want me to give an example (that could actually happen in real life)? If so, I will try to keep it as simple as possible.

So lets say you need to make a function that will take some number and if number is smaller than 5, it will return it's square value. but if the number's value is 4, you don't want to return it's square value, but multiply it by 2 instead. If number is bigger than 5, we just return the number. Can you see where this is going?

If we were to organize our code like this:

```
// EXAMPLE 1
// some code
if (number < 5) {
return number * number;
} else if (number === 4) {
return number * 2;
} else {
return number;
}
// some code
```

Now this would actually never trigger our `number === 4` condition, and we would be missing one most specific case. Our program would still work, and it would work for infinite - 1 number of situations, because ˙we will never check if equals 4 before doing some other operation.
From this it should be obvious that you should always take care of most specific situations first, and more loose later.
Example of how this should have been done:

```
// EXAMPLE 2
// some code
if (number === 4) {
return number * 2;
} else if (number < 5) {
return number * number;
} else {
return number;
}
// some code
```

We could put even more conditions there.
Let say we have to do one action when number equals our specific condition, one when number is in some small range and another when number is in some big range.

```
// EXAMPLE 3
// some code
if (number === 4) {
return number * 2;
} else if (number > 0 && number < 5) {
return number * 3;
} else if (number < 10) {
return number * number;
} else {
return number;
}
// some code
```

I put it like this so you can see that out most specific condition is in our second conditions range. I could have written it like this:

```
// EXAMPLE 4
// some code
if (number > 0 && number < 5) {
if (number === 4) {
return number * 2;
} else {
return number * 3;
}
} else if (number < 10) {
return number * number;
} else {
return number;
}
// some code
```

Notice that in example 4 we would determine that `number = 4`

is in first conditions range, and then check if it's value is equal to 4. In example 3 we would check if number equals to 4 first, and then move on. Now I would say that if you have big number of if's, maybe it would be smarter to use example 4 code since it's better organized I'd say. Otherwise, example 3 all the way.

Now back to example 3. If our number equals to 4, we check it and finish loop. If it equals, lets say 3, we evaluate false in first loop and true in second and finish. If it's -3, we evaluate it as true in third loop and then finish.

I probably said a lot of things here, but I've tried to keep it as simple as possible and with few examples. If you need more explaining, no problem, give me some of examples that are troubling you and I'll try to help explain them, or make another example on my own.