The Mummies also have a good sense of humor and love to see a silly looking pyramid. A silly looking pyramid can either be:

A negative pyramid - any pyramid that has all of its sides with slopes in the range [-89, -1].

A never ending pyramid - any pyramid that has all of its sides with slopes in the range [90, 179].

Our goal will be to check if the slopes of an array create a silly pyramid.

For this we will need to use a function from the Starknet math library 

, which will tell us if a value is less than or equal to another value. Here is an example:

from starkware.cairo.common.serialize import serialize_word

from starkware.cairo.common.math_cmp import is_le

func main{output_ptr : felt*, range_check_ptr}() {

A couple of things to note here. In order to use the 

 (is less than or equal function), we need to add 

 to the list of builtins at the top of the file, each of which is separated by a space. Also, we need to import the function 

. We will be using more and more functions from Starknet libraries.

 will return 1 if the first value is less than or equal to the second value. Note: in Cairo to represent boolean values, use a 

The next thing we will do is return 2 values from our function, each of which is a 

. We could achieve this using one return variable but for the sake of the lesson you will have to solve with multiple return values.

 with values of 1 and 2 respectively in a function with input 

func my_func(x : felt) -> (y : felt, z : felt) {

 so that all the assertions pass. Make sure you use the 

. If you understand what a local variable is, you can use it in your functions, but try to achieve this just using 

Returning multiple values and more recursion

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.