If you are new to Cairo or are experienced, you may have been frustrated with references being revoking. This is a frequent occurrence due to the fact that we have been using 

 to declare variables which rely on the allocation pointer (ap) - think of heap memory - rather than the frame pointer (fp) - think of stack memory.

You may have also noticed that we have organized our code in interesting ways in previous lessons... This was mainly to avoid revoked references.

Note that if there is a label or a call instruction (call to another function. See Functions) between the definition of a reference that depends on ap and its usage, the reference may be revoked, since the compiler may not be able to compute the change of ap (as one may jump to the label from another place in the program, or call a function that might change ap in an unknown way).

' We recommend reading through the references below to really understand revoked references well because they occur frequently in Cairo when not using 

 in most complex scenarios because the likelihood you will get a variable revoked is somewhat high. In simple functions, especially in functions that do not call other functions, 

Let's look at how to make use of these local variables and how they can make our lives better.

from starkware.cairo.common.serialize import serialize_word

If you run these two script in your own code editor or 

 (make sure it is running on Cairo version 0.10.0 or higher) you will see that the first one succeeds, but the second one gets a revoked reference for 

. This is because the allocation pointer lost context of 

 and set it to a local in two steps or you can use the shortcut 

 ... as seen above. In two lines would look like:

 In Cairo you cannot unpack a function call directly into a local variable like:

Last thing to note is that in any function where you use local variables, you must declare 

 at the top of that function. This will handle advancing the allocation pointer for you so you do not have to manually keep everything in sync.

 on the first array and then the second array and returns 1 if both the pyramids are valid and 0 otherwise.

This is an exploratory lesson. Explore what causes functions to revoke references by changing variable instantiation from 

https://www.cairo-lang.org/docs/how_cairo_works/consts.html?highlight=local%20variable#local-vars

Local Variables

Overview: In module two we will get an introduction to the intricacies of arrays. You will deal with recursing through these arrays of felts, known as felt*.

        What you will implement: For this section you will write a function that recurses through an array of numbers, representing the angle of each of the faces of the pyramid with the ground, and ensure the angles are within the safe range prescribed by the Mummies or are to their liking to build a joke pyramid.

        In this section we will cover: arrays (felt*), recursion, builtins, implicit arguments, imports and local variables. You can either skips the step by step lessons and solve the whole chapter or go step by step starting at Lesson 1. See you on the other side.