Search

Geek Girl Joy

Artificial Intelligence, Simulations & Software

Month

October 2017

256 PreTrained Elementary Cellular Automata Neural Networks

Welcome back and happy Friday everyone!

I regularly release new content (including advanced code) that usually goes way beyond any simple proof of concept you can find elsewhere!

If you review my Topics & Posts page you will almost certainly find a project to pique your interest!

Of the topics I have written about already, overwhelmingly the posts on Neural Networks are the most popular! I believe this is the case because unlike other technical writers, I don’t stop at merely describing how things work, my job would be so much easier if I did that! No, I go above and beyond for you guys and release ACTUAL code and REAL neural networks for you guys to learn and use!

I even went so far as to submit them to the official FANN for PHP GitHub Repo so now when you obtain your copy of FANN, the examples are already available to you, for free!

I’m not just talking about all the basic logic gates either! You can get a free copy of a Pathfinding neural network as well as an OCR (Optical Character Recognition) neural network as well! These are REAL examples for you to experiment with!

You can find all my Neural Networking tutorials over on my Topics & Posts page.

Well, today I want to talk to you about 256 Neural Networks that I trained for you to perform all the 1D Wolfram Elementary Cellular Automata rules.

Being that I have released so much free neural network code and tutorials publicly and considering their amazing popularity, I feel like I need to put these behind my Patreon “pay wall”.

Frankly, I much prefer publishing my content for everyone to enjoy but I’m not kidding when I say that It takes a lot of work to make these projects, so… if you like my work then consider becoming my Supporter over on Patreon for as little as $1 getting access to these Neural Networks!

Seriously, at $1 a month… That’s less than 4 cents a day! Your daily coffee costs more than that!

By supporting me you will make it possible for me to focus solely on posting bigger and better projects!

What do you get exactly?

Well, I am publishing everything listed below to the $1 supporter level so for just $12 a year you are going to get the following:

  • 256 training sets (.data files) to review, modify and train neural networks to perform all 256 (0 – 255) rules conveniently organized into separate files and named after the rule that it trains the network on.
  • 256 PRE-TRAINED neural networks (.net files) capable of performing the computation as outlined in my Elementary Cellular Automata series but except via neural networks.
  • 5 separate programs (.php files):
    1. generate_rule_set.php: This program will recreate the entire set of 256 .data training files.
    2. train_all.php:  This program will train all 256 FANN .net neural networks.
    3. train_specific.php: This program lets you enter the rule numbers into an array prior to running to train the specific rules as FANN .net file neural networks.
    4. ann_output_all_rule_set_images.php: This program will render all the rules as images using the neural networks.
    5. ann_output_specific_rule_images.php This program will render the specified rules as images using the specified neural networks.
  • The entire set of rules (0 – 255) pre-rendered as 1025x1025px PNG images.

 

The 256 Neural Networks are waiting for you over on Patreon right now!

You will need PHP and FANN installed for this to work. I have a public tutorial on how to setup your test environment for free here:

 

Please Fund, Subscribe, Like, Share & Comment:

This post was made possible by the generous contributions of my sponsors on Patreon & anonymous contributions to my Bitcoin Tip Jar.

 

 

I will see you all in my next post!

Much Love,

~Joy

 

 

Ancestor Simulations Elementary Cellular Automata Part 4

Happy Thursday evening everyone! I know it’s late, sorry :/

Today we’re going to conclude our examination of 1 dimensional Wolfram Elementary Cellular Automata.

For your convenience, here are the other posts in this series in case you missed them as they will fill in all the details I don’t cover here and I encourage you to go read them as well:

 

When we left off in my last post we were considering how we might use the Cellular Automata function I provided to create images of the rules, which is just one of the many awesome uses for Wolfram Cellular Automata!

Rather than tease you with with the prospect of getting the code and making you wait till tomorrow like I did on Monday and Tuesday I think I’m feeling generous and just going to let you have the code now, give it a quick read through and we’ll discuss it below. 😛

 

// Image Size Setting //////////////////////
$full_size = pow(2, 10) + 1; // 1025
////////////////////////////////////////////

////////////////////////////////////////////
// Run through all rules
for($i = 0; $i <= 255; $i++){
    $cellular_automata = imagecreatetruecolor($full_size, $full_size); /* New Image */
    $black = imagecolorallocate($cellular_automata, 0, 0, 0);  /* Allocate Black */
    $white = imagecolorallocate($cellular_automata, 255, 255, 255); /* Allocate White */
 
    /* Create seed of zeros with a one in the exact center */
    $seed = str_repeat('0', round($full_size / 2) - 1) . '1' . str_repeat('0', round($full_size / 2) - 1);
    
    $current_seed = str_split($seed); /* Split the $seed string into an array */
    
    /* For each value in the current_seed array */
    foreach($current_seed as $col=>$value){
        if($value == 1){ 
            imagesetpixel($cellular_automata, $col, 0, $white); /* Set Pixel */
        }
    }

    /* For each row and column pixel in the image */
    $rule = $i;
    for($row = 1; $row <= $full_size; $row++){
        $seed = ElementaryCellularAutomata($rule, $seed); /* Compute the new $seed */
        $current_seed = str_split($seed); /* Split the $seed string into an array */
        
        /* For each value in the current_seed array */
        foreach($current_seed as $col=>$value){
            if($value == 1){ 
                imagesetpixel($cellular_automata, $col, $row, $white); /* Set Pixel */
            }
        }
    }
    imagepng($cellular_automata, "$rule.png"); /* Output Image */
    imagedestroy($cellular_automata);/* Free memory */
}
echo PHP_EOL . "Program Complete!" . PHP_EOL;
///////////////////////////////////////////////////////

How does it work?

Excellent question!

First I declare a variable called $full_size and  assign it the value of:

$full_size = pow(2, 10) + 1; // 1025

This is because  (1024 % 2)  == 0 and I need it to equal 1 which (1025 % 2) gives me,  this basically just allows a center column of cells, so I need a remainder of 1 when dividing the image into 2 vertical halves.

After that I setup a for loop that will step from 0 to (and include) 255 (all the binary rules 00000000 – 11111111).

I then create an image resource in memory and assign it the name of $cellular_automata followed by allocating the colors $white (255, 255, 255)  and $black. (0, 0, 0) for the image resource to paint with.

I follow that up with this little gem:

$seed = str_repeat('0', round($full_size / 2) - 1) . '1' . str_repeat('0', round($full_size / 2) - 1);

Basically this has to do with dividing the image in half as I mentioned above. What this line says is create a string of zero’s on the left then add a one in the middle cell followed by zeros to the right for the rest of the image.

Once I have my “initial $seed” value I use str_split() to convert the string into an array so that we can step through the array as values and apply color the top row of pixels in the image using the initial seed values. 0 = black & 1 = white.

After that I take the seed and pass it to the ElementaryCellularAutomata($rule, $seed) function I released in my previous post on the subject( Ancestor Simulations Elementary Cellular Automata Part 3 ) so that a new seed can be computed, and the explanation of how that occurs is mainly covered in my last post.

Now I just repeat the step of computing a new $seed for each row of the image based on the previously computed seed and then paint the row’s pixels.

Once the image is ready I save it and destroy the image resource so I can create a new one for the next image, Easy Peasy Lemon Squeezy! 😛

Now I imagine that you would like to get your hands on the code for this project am I right? If you head over to this link on my GitHub you will find EVERYTHING you need to get you started!

ca.php – Contains the code I showcased in these posts and will create images of all the Wolfram rules for you to enjoy at 1025 x 1025 px.

random.php – Will create a random seed and select a random rule and then proceed to generate an image 1025 x 1025 px.

It’s interesting to note that several of the rules generate the Sierpinski Triangle fractal using a vary different method than I used in my post A Chaos Game so if you are looking for a great read and want to learn more about fractals consider giving that post a read. 😉

I hope you have as much fun exploring the Wolfram Code as I had preparing this project for you! 🙂

Are these the “Ancestors” we seek?

I hate to say it, but hardly!

As unquestionably cool as Dr. Stephen Wolframs’s Elementary Cellular Automata are, and despite the fact that they DO exhibit a form emergent behavior, they are incapable (seemingly) of exhibiting anything close to real consciousness and so cannot be the basis of our Ancestors.

I can imagine several ways to make use of CA’s that could lead to more intelligent behaviors but… I am not prepared to explore them at this time.

What Wolfram has suggested is that he believes that Elementary Cellular Automata may be the best way to explain how our universe seemingly self organizes (from a computational perspective) through chaotic means and creates the complex behavior of everything we see around us. He has suggested that perhaps with enough time, processing power and research, a form of Elementary Cellular Automata may be the key to unifying “Classical Physics” the so called “Standard Model” with “Quantum Mechanics” both of which offer the ability to correctly make predictions about the universe while remaining incomplete.

If indeed we are living in a simulation then perhaps Rule 30 which IS found nature, in conjunction with Rule 110 represent the greatest hidden fingerprint (signature?) left behind by the programmer who created our universe…

Then again, it may just be a weird little quirk of how patterns of strings of binary data behave when you apply intelligent binary rule sets to manipulate them.

Is it a mysterious code hidden in the numbers that reveals that we are living in the Matrix or simply a glimpse at one of the many forms of complex beauty that math reveals? You are free to draw your own conclusions.

Is that all there is? Can’t we do anything else with the Elementary Cellular Automata?

Well… there is one thing… maybe a neural network, or more like 256 Neural Networks! 😉

Come back tomorrow and I’ll tell you all about it.

Please Fund, Subscribe, Like, Share & Comment:

This post was made possible by the generous contributions of my sponsors on Patreon.

 

 

I will see you all in my next post!

Much Love,

~Joy

 

 

Ancestor Simulations Elementary Cellular Automata Part 3

Welcome back everyone for my third post all about Elementary Cellular Automata!

For reference here are the other posts in this series in case you missed them as they explain quite a bit about how this code works!

Ancestor Simulations Elementary Cellular Automata

Ancestor Simulations Elementary Cellular Automata Part 2

So, I know I have been making you wait for the code but rest assured that you are going to get code today I promise! 😉

But, before we get to the code I would like to take this opportunity to say thanks for reading my posts!

I truly appreciate all of my readers so I put a lot of time into selecting great projects for you to read about and tons of effort into implementing interesting code, creating or editing “featured” images as well as other graphical content that I use in these posts as well as simply curating an active public code base over on my GitHub profile, and frankly it’s a lot of work so if you would like to help support my work or just say thanks for the edutainment , please consider supporting me over on Patreon for as low as $1 dollar a month $12 a year.

Donations will go toward making improvements in my technology stack so that I can make even more cool stuff for you guys!

So without further ado, lets get to the code, shall we? This is the function you need in order to compute the Wolfram code using a 1D cellular automaton!

 

ElementaryCellularAutomata()

This function has two parameters, $rule and $seed.

$rule – Accepts integer values between 0 & 255.

$seed – Accepts string values containing only 1 or 0.

There is no error checking to enforce these conditions as I wanted this to be a clean example and I assume that you will take heed of these requirements in your own implementations.

function ElementaryCellularAutomata($rule, $seed){
    $seed = str_split($seed); /* Split $seed string into array */
    $seed_length = count($seed); /* How long is the seed array */
    $new_seed = "";
    
    if(strlen($rule) < 8){ /* If rule is dec */
            $rule = sprintf('%08b', $rule); /* Convert rule to bin */
    }$rule = str_split($rule); /* Split the binary value of $rule as a string into an array */

    /* For each value in the seed */
    for($i = 0; $i < $seed_length; $i++){
        $left = $center = $right = null; /* set all positions to null */

        /* $left */
        /* If this is the first element in the array */
        /* Wrap around and set $left to last element in array */
        /* Otherwise $left = the element to the left of $center */
        if($i == 0) {$left = $seed[$seed_length - 1];}
        else{$left = $seed[$i - 1];}
        
        /* $center */
        /* Set $center to the current position */
        $center = $seed[$i];
        
        /* $right */
        /* If this is the last element in the array */
        /* Wrap around and set $right to first element in array */
        /* Otherwise $right = the element to the right of $center */
        if($i + 1 >= $seed_length) {$right = $seed[0];}
        else{$right = $seed[$i + 1];}
        
        // Apply Rule ///////////////////////////////////////////////////////////
        if($left == 1 && $center == 1 && $right == 1){$new_seed .= $rule[0];}
        elseif($left == 1 && $center == 1 && $right == 0){$new_seed .= $rule[1];}
        elseif($left == 1 && $center == 0 && $right == 1){$new_seed .= $rule[2];}
        elseif($left == 1 && $center == 0 && $right == 0){$new_seed .= $rule[3];}
        elseif($left == 0 && $center == 1 && $right == 1){$new_seed .= $rule[4];}
        elseif($left == 0 && $center == 1 && $right == 0){$new_seed .= $rule[5];}
        elseif($left == 0 && $center == 0 && $right == 1){$new_seed .= $rule[6];}
        elseif($left == 0 && $center == 0 && $right == 0){$new_seed .= $rule[7];}
        /////////////////////////////////////////////////////////////////////////
    }

    /* Return the new seed which was created by applying the rule set */
    return $new_seed; 
}

The function above will use the rule to compute the new seed and return it as a string. This allows the output of this function to be fed back into it during a loop however you might wish to implement a recursive function that will call itself until a condition has been met and that would operate just as well though depending on implementation some coders may find it harder to read and debug than a purely functional approach which I demonstrate here.

Now you might be wondering how you would use this to generate images of all the rules using  the “initial seed”  we used yesterday, for reference code here is the seed again:

Initial Seed

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0

 

Tell you what… come back tomorrow and I will give you that code too, sound like a plan? Great! I will see you tomorrow! 😉

 

Please Fund, Subscribe, Like, Share & Comment:

This post was made possible by the generous contributions of my sponsors on Patreon.

 

 

I will see you all in my next post!

Much Love,

~Joy

 

 

Ancestor Simulations Elementary Cellular Automata Part 2

Today we’re going to continue our examination of 1 dimensional Wolfram Elementary Cellular Automata by examining Rule 1 (00000001) and manually step through a few cycles or generations.

We will create a 1D grid with a length of 24 + 1 (17) so that we have a center value equal distance from both ends, we will assign all cells the off state except for the center cell which we will turn on.

Like this

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0

 

We will call this our “initial seed” value. Wolfram CA rules are usually demonstrated with some version of this seed, though it is important to remember that the length can be as long as you want, both shorter or longer and the cell states can be set however you need them to begin.

Before proceeding review the neighborhood because it is now important to understand this:

The Wolfram Neighborhood

 

Lets look at Rule 1(00000001) and get started computing new cell states.

Rule 1

R1 R2 R3 R4 R5 R6 R7 R8
111 110 101 100 011 010 001 000
0 0 0 0 0 0 0 1

 

If you imagine the rule 1 table above as an “array” then the first row represents the “keys” and below I will refer to R8 or R6 or other keys by these names as shortcuts that are referring to the  neighborhood patterns on the second row, example R3 refers to a neighborhood pattern of a left cell of 1, a center value of 0 and a right value of 1… got it?

Just to be sure that you are able to follow along  consult the center values in the initial seed, its a 1 and to its left is a 0 and to it’s right is also a 0, therefore on the center position in the “new seed” we will apply R6 which means the new center value would be a 0 Still with me? Good! 😉

Only one more thing to talk about before we get to computing and that is how to handle the edge cells which are the first cell $seed[0] and the last cell of the seed $seed[17] . Because there is no $seed[-1] and $seed[18] there are two options for handling this scenario. A lot of people simply say those positions are 0’s (or 1’s depending on the case) but I like the second option which is to wrap around and grab the value at the other end of the seed. This methodology allows the patterns to wrap rather than stop when an edge is encountered however depending on your use needs you may want to wrap or use a hard value, neither way is technically correct.

So now that we are on the same page lets start figuring out what rules to use to compute the new seed.

 

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
R8 R8 R8 R8 R8 R8 R8 R7 R6 R4 R8 R8 R8 R8 R8 R8 R8

 

 

We can replace the rules with their values and then figure out what rules to use next:

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1
R1 R1 R1 R1 R1 R1 R2 R4 R6 R7 R5 R1 R1 R1 R1 R1 R1

 

And if we replace the rules with the rule values you can see we are back where we started:

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0

 

This pattern will repeat over and over again until we decide to stop, here’s 14 more generations to demonstrate:

The Finished Rule 1 Image

 

This isn’t always the case however, lets look at a different rule that will give us many more interesting neighborhood patterns, Rule 26 (00011010)!

Rule 26

R1 R2 R3 R4 R5 R6 R7 R8
111 110 101 100 011 010 001 000
0 0 0 1 1 0 1 0

 

Notice that we reset the seed to what we started with so that we can illustrate the differences in the rules. Nothing prevents us from using the output of Rule 1 (or any rule) as the input seed for another rule, in fact you can get some very interesting results by doing that!

Notice also that because the seed is the same as before, if we fill in the cell rules they are same neighborhood patterns that we used before, what’s different this time is the values the patterns are mapped to.

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
R8 R8 R8 R8 R8 R8 R8 R7 R6 R4 R8 R8 R8 R8 R8 R8 R8

 

If we replace the neighborhood pattern with the rule value we get a completely different result than we got with Rule 1 before! While we’re at it lets also fill out the next set of rules too:

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0
R8 R8 R8 R8 R8 R8 R7 R6 R3 R6 R4 R8 R8 R8 R8 R8 R8

 

Once again we replace the cell rule with the rule value and we have a completely different grid, we also figure out the next row’s rule patterns:

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0
R8 R8 R8 R8 R8 R7 R6 R4 R8 R7 R6 R4 R8 R8 R8 R8 R8

 

OK lets now convert those rules to values to see what we get:

 

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0
0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0

 

Here’s 12 more generations, there is a pattern but its not quite like the pattern that Rule 1 gave us:

The Finished Rule 26 Image

 

I was going to start looking at code with you today but it’s getting late and this post is already fairly long so come back tomorrow and we will FINALLY dig into the code 😛  have a great evening everyone!

Please Fund, Subscribe, Like, Share & Comment:

This post was made possible by the generous contributions of my sponsors on Patreon & anonymous contributions to my Bitcoin Tip Jar.

 

 

I will see you all in my next post!

Much Love,

~Joy

 

 

Ancestor Simulations Elementary Cellular Automata

Today we open another chapter in Ancestor Simulations, namely “LIFE” or rather our exploration of simulating our “Ancestors” and therefore it behooves us to start with Cellular Automata.

Originally conceived of in the 1940’s by Stanislaw Ulam and John von Neumann (who should be among your personal heroes because of their scientific brilliance by the way 😛 ) consist of a discreet grid of “cells” which can be represented in one or more dimensions.

5x5-grid

Example of a 5×5 two dimensional grid

The cells can have properties assigned to them and cells can exhibit varying types of behaviors called “states” which the cells are said to be “in”.

Various “Rules” are applied to determine when cells can change states and if so, what states can they change to, the most common of which (and simplest) are “Alive” and “Dead“.

Often the grid is encoded as digital data using 0 to mean the cell is switched “Off” or “Dead” and 1 to mean the cell is switched “On” or “Alive”.

Frequently it is more convenient for people to view the grid encoded as pixels rather than ones and zeros and the simplest way to go about visualizing the data is to assign the on and off states separate color values, such as white and black, although black and red or white and blue are also fairly popular.

Often the rules used to determine the cell states involve checking to see what states the “neighborhood” (the cells around the current cell ) are in.

The Von Neumann Neighborhood

If the blue cell is the current cell being examined then the “Von Neumann Neighborhood” examines the four cells surrounding it in the four  cardinal directions directly around the current cell (shown in red) and the “extended neighborhood” would then include the cells in pink.

 

The Moore Neighborhood

If the blue cell is the current cell being examined then the “Moore Neighborhood” examines the eight cells surrounding it directly around the current cell (shown in red) and the “extended neighborhood” would then include the ring of cells around the red cells.

 

The Wolfram Code

We’ll cover 2D Cellular Automata  in future posts because today we are going to look at one of the simplest cases of a CA, namely a 1 dimensional Wolfram CA called the Wolfram Code.

Originally discovered by Stephen  Wolfram in the early 1980’s when he was studying computer simulations and the nature of the universe… kinda like we are doing with our Ancestor Simulation! 😉

I called the Wolfram code “simple” only because it “has fewer moving parts” so to speak, it is still capable of complex behavior, including modeling Chaos Theory so as such the Wolfram code embodies emergent behavior very elegantly!

Emergence is the idea that simple rules can be implemented and followed and their results can lead to highly complex behaviors and structures that somehow “emerge” without having to be specifically implemented or designed into the system.

Unlike the 2D grid “neighborhoods” (Von Neumann & Moore) outlined above the 1D Wolfram CA is just a single row of boxes. Technically It need not be 1D but the Wolfram CA is usually introduced and discussed as a 1D CA and as such, when we think of the resulting output we think of it more as a series of time steps away from the original pattern. That is to say that while we display the output of the Wolfram CA in 2D image just like other CA’s, the 2D grids are computed row by row whereas any given image of a 2D CA is computed entirely and then rendered.

This means that that the image generated by the Wolfram CA is the sum of all the states or calculations that occurred and each row, being the resulting sum of states or calculations occurring at n-generation and is n rows (steps) away from the originating pattern.

The Wolfram CA allows for an arbitrary length (meaning the length can be as long as you want) with a minimum size of 3 because the Wolfram CA has a neighborhood that consists of 3 cells. the cells to the direct left and the direct right (shown in red) of the cell being considered (shown in blue).

The Wolfram Neighborhood

 

An interesting result of this is that with a 3 cell neighborhood and 2 states (on & off) there are 23 (8) possible state combinations for a given neighborhood and 28 (256) possible rules.


$number_of_rules = pow(2, pow(2,3)); // 256

 

Because there are only 2 possible cell states and only 8 values are needed to encode each possible rule, we can generate all of the Wolfram CA rules using this code:

 

for($i = 0; $i < $number_of_rules; $i++ ){
    printf("$i: " . '%08b' . PHP_EOL, $i);
}
/*
0: 00000000
1: 00000001
2: 00000010
3: 00000011
4: 00000100
5: 00000101
6: 00000110
7: 00000111
8: 00001000
9: 00001001
10: 00001010
...
250: 11111010
251: 11111011
252: 11111100
253: 11111101
254: 11111110
255: 11111111
*/

 

The cell states are checked against these rule patterns and in this order:

R1 R2 R3 R4 R5 R6 R7 R8
111 110 101 100 011 010 001 000

Therefore if the neighborhood pattern was 111, the first value of the rule is applied. If it is 110 the second it used and so forth.

Some of the rules like Rule 30 (00011110) in combination with Rules 86 (01010110) , 135 (10000111) and 149 (10010101) have been shown to encode chaotic behavior.

Other rules are either suspected of being “Turing Complete” (without a “formal proof” having been created or discovered yet) or ARE known to be Turing complete such as Rule 110 (note this refers to the octet binary representation for the number 110 (01101110)  not the 3 cell neighborhood pattern 110 (R2) as shown in the table above).

For example, here is the results of Rule 73 (01001001) when initialized with a single “living” cell in the center of the image on row: 0 col: 513:

Click for full Size

And with that, have a great evening everyone!

Come back tomorrow for the next part of this post which will include my implementation of a 1D Wolfram Automata which I used to generate the image above.

Please Fund, Subscribe, Like, Share & Comment:

This post was made possible by the generous contributions of my sponsors on Patreon.

 

 

 

I will see you all in my next post!

Much Love,

~Joy

 

 

Blog at WordPress.com.

Up ↑

%d bloggers like this: