 So far we've used the jump and link instruction when we want to call a function. The jump and link instruction asks the assembler to fill in the actual address of our function into the jump and link instruction. But we could also put that address into a register. We've already used the load address instruction to place the address of a string into a register for us, but we could also ask it to place the address of a function into a register. That would give us a function pointer. Now that we have a function pointer, the function can be considered a first class member of the language, which means we can do a number of other things with it. We can pass it as a parameter. We can have a function that takes another function as one of its arguments. We can also take that function pointer and we can store it in a data structure. But we can still call it as though it's a regular function using the jump and link register instruction. This instruction works just the same way as our original jump and link did, but it's going to get the address of the function from a register instead of from the instruction itself. This will enable us to do a couple of really interesting things. One of which is that we can choose what function we're running at runtime. We can build data structures that contain pointers to functions so we know which functions we should actually use with this data structure. If we apply some abstraction on top of that, we can actually get polymorphism out. That's what we're going to look at next time is how we can use function pointers to allow us to implement polymorphism even at the assembly language level.