Time to play variable cleanup

7-1-2018

During the programming of this game, I often start to add a great number of variables for testing various routines. It gets far out of hand sometimes and starts eating up the memory bit by bit. Furthermore, there are variables that can be reused that can also help with saving memory.

Luckily, I do have a few tools at my disposal and want to share the techniques that I employ to find those variables.

First things first, in Z88dk, it pays to have the variables all as globals and try to skip local optimizations by having a localized variable within a function.

So the first problem is finding localized variables and moving them to globals.

The second problem is identifying superfluous variables used for testing.

The third problem is to identify variables that might be reused.

Luckily, I have placed a vast majority of my variables in a separate header file called, variables.h

Right now, our variables.h file looks like this:

////////////////////////////////////
//         GLOBAL VARIABLES       //
////////////////////////////////////

unsigned char data[20]= 
{
  0, 0, 0, 0,
  0, 0, 0, 0,
  0, 0, 0, 0,
  0, 0, 0, 0,
  0, 0, 0, 0
};//enemy placement data

unsigned char grassfire[150] = {
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};


char enemyDirections[4] = {
    0,0,0,0
};

short levelPositioning [3] = {0,0,0};

char dirbul[4];

//globals
char i, j;
unsigned int killed;
char mapx, mapy;
char spacepressed;

unsigned char gameMap;

char yourScoreTXT[20] = "000000000";//000,000,000
char yourLivesTXT[3] = "05";
char gameOverTXT[10] = "GAME OVER";
char gameStartTXT[10] = "GET READY";
char highScoreMessage1[16] = "CONGRATULATIONS";
char highScoreMessage2[26] = "YOU HAVE A NEW HIGH SCORE";
char clearTXT[10] = "         ";
long yourScore;//2,147,483,647 max
char yourLives;
char scoreTxT[6] = "Score";
char livesTxT[6] = "Lives";
char highScoreText[20] = "The Top Scores are:";

int timeout;

char initials[2]  = "\0";

int bobbie;
char buffer[2] = "\0";
int letter;


//temp variables
    char in1[10] = "         ";
    char in2[10];
    char in3[10];
    char in4[10];
    char output[40];
    int noggin;
//temp variables

char firstInital = 65;//letter A
char secondInital = 65;//letter A
char thirdInital = 65;//letter A
char initals[5] = "AMD";

short _g_str_x;
short _g_str_y;
short _g_mask;
unsigned char *textString;

char buildMap;// are you currently playing
char loop;
char xx, yy;

static unsigned short jz,jsr=5;//used in randomizer

unsigned char level;//which game level are we on

short x, vx, ax;
short y, vy, ay;
unsigned char movePlayer;

//unsigned int romCounter;//fake randomize function
//unsigned char randomNumber;//fake randomize function

short xx1, xx2, yy1, yy2, xx3, xx4, yy3, yy4;

unsigned char isLevelRead;//used to read each level when loaded in memory

//short count;//count how many items are in the array    
//short tile;


char enemySlowDown;
char enemySpeedUp;

unsigned char lives;

unsigned short playerXpos;//player X position 0-255
unsigned short playerYpos;//player Y position 0-172
unsigned char playerXattr;//player x attribute position
unsigned char playerYattr;//player y attribute position


//ATTENTION
//these temporary variables are to be used with functions
unsigned char screenX;
unsigned char screenY;
unsigned char count;//count how many items are in the array    
unsigned char tile;
unsigned char attribute;
unsigned char objectRadius;
unsigned char differenceX,differenceY, difference;

unsigned char tmpx1, tmpy1, tmpx2, tmpy2;
unsigned char iterator;
short squaredRadius, squaredDifferenceX, squaredDifferenceY;
unsigned char enemyPosition;
//these have to be shorts or larger because the numbers are too large to fit in char

unsigned char enemyX,enemyY,enemyF,enemyImage,enemyStatus;
unsigned short decision, enemyRetreat;
unsigned char enemySteps;


unsigned char playerCharX;//playerCharX character range 0 - 15
unsigned char playerCharY;//playerCharY character range 0 - 9


unsigned char singleBullet;
char num_bullets;
char k;


// create variables    
unsigned char barrierPosition;
    
unsigned char enemyCharX;//enemyCharX character range 0 - 15
unsigned char enemyCharY;//enemyCharY character range 0 - 9

unsigned char xCenterofTile, yCenterofTile;

unsigned char enemyCenter;
unsigned char enemyXwest, enemyXeast;
unsigned char enemyYnorth, enemyYsouth;

unsigned char centerValue;
unsigned char northValue;
unsigned char southValue;
unsigned char eastValue;
unsigned char westValue;
unsigned char tileCenter;
unsigned char compare1,compare2,compare3;
unsigned char center, north, south, east, west;

unsigned char enemyDirection;// move the enemy X number of steps from the obstacle
unsigned char enemyObsticleTrace;//
unsigned char barrier;
//playerX pixel range 0 - 240
//playerY pixel range 0 - 160
//enemyX pixel range 0 - 240
//enemyY pixel range 0 - 160

unsigned char arrayCounter;

// these are exclusively for  wave-front scanner
unsigned char screenScanX, screenScanY, screenCounter, screenCounterStart, screenCounterEnd;//only use this during partial screen scanner in enemies.h
    
//these temporary variables are to be used with functions
//ATTENTION

char str[20];
unsigned char bob = 0;//used to print to screen
unsigned char sue;//used to print to screen also
unsigned char test;
unsigned char scanx, scany;
////////////////////////////////////
//         GLOBAL VARIABLES       //
////////////////////////////////////

Quite a few variables that I have going on here. I have stuffed the variable list with a number of temporary variables that are useless for anything other than when I was testing items.

My program compiled size at this moment is 10471 bytes free.

So, let’s talk about the most valuable tool that I will use for this.

The search feature in Notepad ++.

Quite a simple tool, yet this will help you considerably. Especially when we can search across files.

We will begin by opening up our variables.h file in notepad ++ and find the first variable that we want to research.

Just for fun, let’s look at the array

unsigned char data[20]= 
{
  0, 0, 0, 0,
  0, 0, 0, 0,
  0, 0, 0, 0,
  0, 0, 0, 0,
  0, 0, 0, 0
};//enemy placement data

I know what this particular variable is used for, so I know I won’t be eliminating it, but we can use this as a test case.

So, I am going to copy the variable name and open up the find feature in Notepad ++, open the Find in Files tab and type in the variable name (alternately, you can copy the name and paste it into the field).

Make sure the search directory is set to the correct directory and simply “Find All”.

Zoinks, you are going to find a lot of occurrences of the variable name “data”

Let’s try another search.

This time we are going to search “data[” (notice the brace I added to the end. This will eliminate quite a few results.

And it works, we can see that the array “data” is used in main.c, gamedisplay.h and mapsandstart.h, so this is not an obsolete variable and we can leave it alone.

Now, that is not the case with all variables, we may have to look at a particular variable to see again what its purpose is and if we can reuse another variable name in its place.

Let’s search for another, our next target is

char enemyDirections[4] = {
	0,0,0,0
};

The “Find All” feature in Notepad ++ reveals that the variable is declared only and never used. This is an obvious unused variable and needs to be tagged for removal. But before we start just deleting variables, let’s tag it in a special section in our variables.h. To prepare a variable for removal, I’m going to be placing a special section within my variables.h header where I still keep the variable name, yet, have not eliminated it yet.

My section in this header looks simply like this

/////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for REMOVAL //
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for REMOVAL //
/////////////////////////////////////////////////////////////////

Nice and cleanly marked, now let’s move our variable to it. Furthermore, let’s comment out the variable.

/////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for REMOVAL //
/////////////////////////////////////////////////////////////////

/*char enemyDirections[4] = {
	0,0,0,0
};*/

/////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for REMOVAL //
/////////////////////////////////////////////////////////////////

Now, let’s try to compile the code and see if there are any error messages.

On compiling, I find there are no complaints, now let’s run our game to make sure it runs the same. We will discover that all seems to be well.

There are now 10475 bytes free. We saved 4 bytes just by eliminating 1 variable. Not a huge saving, but it does clean up our code just by a little.

Now, we need to go through our variables one at a time, search to see if the variable is being used or just declared and move that variable to our tagged location and comment out the variable. It’s a tedious process, but so is cleaning the house. Takes time, but the results are a cleaner code to work with.

Another interesting example I will now show are the variables

char xx, yy;

The variable xx is used only once in our routine.

void printHighScores()
{
    PrintStr(highScoreText, 0x0103);
    insertionSort();
    xx = 0x0405;
    
    for (screenCounter = 0; screenCounter < 5; screenCounter ++)
    {
        strcpy (str," ");
        strcat (str,scores[screenCounter].hiInitals);    //Concatenate strings
        strcat (str,"....");
        
        ltoa(scores[screenCounter].hiScoreList, yourScoreTXT , 10);//use lota for long variables
        strcat (str,yourScoreTXT);
        
        PrintStr(str, xx);
        
        xx++;        
    }
    
    Pause (100);    
}

This routine (which I haven’t blogged about just yet) uses xx as a temporary variable to place the string “str” on the screen. The variable is used only once in the program. So, to tag this variable, I’m going to have another section in my variables.h function to tag it for further inspection.

////////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for INSPECTION //
////////////////////////////////////////////////////////////////////
char xx, yy;

static unsigned short jz,jsr=5;//used in randomizer
////////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for INSPECTION //
////////////////////////////////////////////////////////////////////

Note, I am not commenting out these variables, I’m just organizing them for further inspection.

So after a bit of time, I researched all of my unused variables and have now moved them to my section to tag for future removal. What a list it is.

////////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for REMOVAL //
////////////////////////////////////////////////////////////////////

/*char enemyDirections[4] = {
	0,0,0,0
};*/
//unsigned int killed;
//int bobbie;

//char initals[5] = "AMD";

//temp variables
//	char in1[10] = "         ";
//	char in2[10];
//	char in3[10];
//	char in4[10];
//	char output[40];
//	int noggin;
//temp variables


////   Moved from Function ////
//short vY1, aY1, YY1;//eliminated
//short vX1,aX1,XX1;
//char buildMap;// are you currently playing

//char loop;
//short xx3;
//short xx4;
//short yy3;
//short yy4;

//short count;//count how many items are in the array	
//short tile;
//unsigned char lives;
//unsigned char objectRadius;
//unsigned char tmpx2;
//unsigned char tmpy2;

//short squaredRadius, squaredDifferenceX, squaredDifferenceY;

//unsigned short decision;
//unsigned char barrierPosition;
//unsigned char enemyCenter;
//unsigned char enemyXwest, enemyXeast;
//unsigned char enemyYnorth, enemyYsouth;
//unsigned char tileCenter;
//unsigned char enemyObsticleTrace;
//unsigned char barrier;
//unsigned char bob = 0;//used to print to screen
//unsigned char sue;//used to print to screen also
//unsigned char test;
//unsigned char scanx, scany;
//long scorearray[6] = {0,0,0,0,0,0};
// short horizonal [3] = {0,0,0};
// short vertical [3] = {0,0,0};


////////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for REMOVAL //
////////////////////////////////////////////////////////////////////

My list tagged for future examination is:

////////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for INSPECTION //
////////////////////////////////////////////////////////////////////
char xx, yy;

static unsigned short jz,jsr=5;//used in randomizer

unsigned char screenX;
unsigned char screenY;
////////////////////////////////////////////////////////////////////
//  VARIABLES TAGGED for INSPECTION //
////////////////////////////////////////////////////////////////////

A much shorter list indeed.

Now my compiled size is 10628 bytes free from the original 10471, a savings of 157 bytes.

That, however, is just one tool we can use, now, using that particular technique we can follow plenty of variables, we still have Cpp Check (http://cppcheck.net/) available to us as well.

I’m not going to talk about how to setup Cpp Check, it’s rather intuitive to setup and use, however using it I find several issues. Such as the error – gamedisplay.h – Array ‘initials[2]’ accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]. This is kind of a large error, which could not only crash the game but also serve as a memory leak, so correcting it, will help with that issue.

That’s easily corrected by making that particular array just a little larger.

From

char initials[2]  = "\0";

To

char initials[4]  = "\0";

I also forgot about a variable that I left in a function.

gamedisplay.h – (style) The scope of the variable ‘scr’ can be reduced.

It’s actually 3 variables.

unsigned int scr, dst;
char count;

I should be able to directly remove the count variable, as there is one in the globals already.

As for the other 2 variables, I can move those to the globals and just make a notation what they are used for.

I also find other loose variables.

long key;
char hiTemp[4];

Moving those variables and recompiling, we now have 10696 bytes free.

I also discover another error

movement.h – The unsigned variable ‘north’ will never be negative so it is either pointless or an error to check if it is.

The original routine looks like.

{
    north = playerCharX + scrw * (playerCharY - 1);    
    if ((north  150))
        north = center;
}
    
{
    south = playerCharX + scrw * (playerCharY + 1);
    if ((south  150))
        south = center;
}
    
{
    east = playerCharX + 1 + scrw * playerCharY;
    if ((east  150))
        east = center;
}
    
{
    west = playerCharX - 1 + scrw * playerCharY;
    if ((west  150))
        west = center;
}

So I replace it with.

{
    north = playerCharX + scrw * (playerCharY - 1);    
    if (north > 150)
        north = center;
}
    
{
    south = playerCharX + scrw * (playerCharY + 1);
    if (south > 150)
        south = center;
}
    
{
    east = playerCharX + 1 + scrw * playerCharY;
    if (east > 150)
        east = center;
}
    
{
    west = playerCharX - 1 + scrw * playerCharY;
    if (west > 150)
        west = center;
}

And not only does the error go away, but I capture some more memory and now I have 10772 bytes free.

As a side effect, the enemies move a little faster since there are fewer items to check.

A tip I have found out is that:

An unsigned char performs better than a signed char.

This, of course, means we should inspect every instance of a signed char and see if it is appropriate to change it to an unsigned char.

Another tip I have found is:

Declare most frequently used variables last

So, in this case, I will be going back to notepad ++. Using the Find in Files function. Type in a variable name, select Match whole word only and find how many times the variable is used. Try to target routines that are called more often and variables that are the most used within those functions.

Make notation of how many times those variables are called and then move the definition of that variable to the bottom of your variables.h file.

One note, I want to emphasize that there is a good reason to use long variable names, not only is it easier to write code and the variable is self-explaining, it also makes this particular search easier to perform.

For example:

I know that the variable

int timeout;

is not used very often, in fact it’s only really used at the main menu, whereas the variable

unsigned char centerValue;

is used during the main game loop during the enemy AI. It makes much more sense to place the variable timeout at the top of the list and place centerValue at the bottom. This way when the stack is addressed, it can pull the most often used variable quicker.

Make sure the variables are of the correct type.

I noticed in my code, I have a variable used to select a letter, the variable never goes above 90 and never below 65, yet the variable is defined as

int letter;

Let’s change that to a

unsigned char letter;

This should make the code a bit more efficient. Let’s hope it does its job.

Now my code size is 10851 bytes free. A bit of a savings, I’m rather pleased because I just saved 380 bytes by just removing some junk variables and the game seems to run faster with differences.

My globals now look like this

////////////////////////////////////
//         GLOBAL VARIABLES       //
////////////////////////////////////


//////////////////////////////////////
//  VARIABLES TAGGED for INSPECTION //
//////////////////////////////////////
char xx, yy;

static unsigned short jz,jsr=5;//used in randomizer

unsigned char screenX;
unsigned char screenY;
//////////////////////////////////////
//  VARIABLES TAGGED for INSPECTION //
//////////////////////////////////////


/////////////// LEAST USED VARIABLES

//used for our high Score List
struct HiScore {
   char hiInitals[4];
   long hiScoreList;
};

struct HiScore scores[] = 
{
    {"AMD", 2147483646L},
    {"BAZ", 1024L},    
    {"ANT", 16384L},
    {"RVG", 65535L},
    {"JIM", 255L},
    {"GNU", 512L}
};
//used for our high Score List

unsigned char yourScoreTXT[20] = "000000000";//000,000,000
unsigned char yourLivesTXT[3] = "05";
unsigned char gameOverTXT[10] = "GAME OVER";
unsigned char gameStartTXT[10] = "GET READY";
unsigned char highScoreMessage1[16] = "CONGRATULATIONS";
unsigned char highScoreMessage2[26] = "YOU HAVE A NEW HIGH SCORE";
unsigned char clearTXT[10] = "         ";
long yourScore;//2,147,483,647 max
unsigned char yourLives;
unsigned char scoreTxT[6] = "Score";
unsigned char livesTxT[6] = "Lives";
unsigned char highScoreText[20] = "The Top Scores are:";
unsigned char initials[4]  = "\0";
unsigned char buffer[2] = "\0";
char str[20];

unsigned char letter;
int timeout;

unsigned char firstInital = 65;//letter A
unsigned char secondInital = 65;//letter A
unsigned char thirdInital = 65;//letter A

//used for display especially with 128k
short _g_str_x;
short _g_str_y;
short _g_mask;
unsigned char *textString;
//used for display especially with 128k


unsigned char data[20]= 
{
  0, 0, 0, 0,
  0, 0, 0, 0,
  0, 0, 0, 0,
  0, 0, 0, 0,
  0, 0, 0, 0
};//enemy placement data

unsigned char grassfire[150] = {
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
//used for our Grassfire AI



short levelPositioning[3] = {0,0,0};

char dirbul[4];//used for bullets

//globals
char i, j;

char mapx;//used for indexing screen
char mapy;//used for indexing screen
char spacepressed;//used for firing bullets

unsigned char gameMap;//used to pull up a new maps
unsigned char level;//which game level are we on
unsigned char isLevelRead;//used to read each level when loaded in memory

//from _show_str()
unsigned int scr, dst;
//    char count;

long key;
char hiTemp[4];

/////////////// LEAST USED VARIABLES

/////////////// MID RANGE VARIABLES
//speeds up and slows down the enemies
unsigned char enemySlowDown;
unsigned char enemySpeedUp;
//speeds up and slows down the enemies

unsigned char xCenterofTile, yCenterofTile;// used to detect if enemy is in the center of the tile

unsigned char singleBullet;
char num_bullets;
char k;

unsigned char enemyRetreat;//used when calling moveEnemy
unsigned char enemySteps;//used when calling moveEnemy
unsigned char enemyDirection;// move the enemy X number of steps from the obstacle
//used when calling moveEnemy

/////////////// MID RANGE VARIABLES

/////////////// MOST USED VARIABLES



short x, vx, ax;
short y, vy, ay;

unsigned char movePlayer;//animation for player sprite 

short xx1;//used in collision of player
short xx2;//used in collision of player
short yy1;//used in collision of player
short yy2;//used in collision of player


//ATTENTION
//these temporary variables are to be used with functions

unsigned char count;//count how many items are in the array    
unsigned char tile;
unsigned char attribute;

unsigned char differenceX;//used in taxicab difference
unsigned char differenceY;//used in taxicab difference
unsigned char difference;//used in taxicab difference

unsigned char tmpx1;//used to detect if bullet hit enemy
unsigned char tmpy1;//used to detect if bullet hit enemy

unsigned char iterator;
unsigned char arrayCounter;
//ATTENTION
//these temporary variables are to be used with functions
unsigned char enemyPosition;



unsigned char enemyX,enemyY,enemyF,enemyImage,enemyStatus;

//only use this during partial screen scanner in enemies.h
unsigned char screenScanX;
unsigned char screenScanY;
unsigned char screenCounter;
unsigned char screenCounterStart;
unsigned char screenCounterEnd;
//only use this during partial screen scanner in enemies.h

//players position
unsigned short playerXpos;//player X position 0-255
unsigned short playerYpos;//player Y position 0-172
unsigned char playerXattr;//player x attribute position
unsigned char playerYattr;//player y attribute position



unsigned char playerCharX;//playerCharX character range 0 - 15
unsigned char playerCharY;//playerCharY character range 0 - 9
unsigned char enemyCharX;//enemyCharX character range 0 - 15
unsigned char enemyCharY;//enemyCharY character range 0 - 9
//playerX pixel range 0 - 240
//playerY pixel range 0 - 160
//enemyX pixel range 0 - 240
//enemyY pixel range 0 - 160
//players position



//used for our Grassfire AI
unsigned char centerValue;
unsigned char northValue;
unsigned char southValue;
unsigned char eastValue;
unsigned char westValue;
unsigned char compare1;
unsigned char compare2;
unsigned char compare3;
unsigned char center, north, south, east, west;

/////////////// MOST USED VARIABLES



///////////////////////////////////
//  VARIABLES TAGGED for REMOVAL //
///////////////////////////////////

/*char enemyDirections[4] = {
    0,0,0,0
};*/
//unsigned int killed;
//int bobbie;

//char initals[5] = "AMD";

//temp variables
//    char in1[10] = "         ";
//    char in2[10];
//    char in3[10];
//    char in4[10];
//    char output[40];
//    int noggin;
//temp variables


////   Moved from Function ////
//short vY1, aY1, YY1;//eliminated
//short vX1,aX1,XX1;
//char buildMap;// are you currently playing

//char loop;
//short xx3;
//short xx4;
//short yy3;
//short yy4;

//short count;//count how many items are in the array    
//short tile;
//unsigned char lives;
//unsigned char objectRadius;
//unsigned char tmpx2;
//unsigned char tmpy2;

//short squaredRadius, squaredDifferenceX, squaredDifferenceY;

//unsigned short decision;
//unsigned char barrierPosition;
//unsigned char enemyCenter;
//unsigned char enemyXwest, enemyXeast;
//unsigned char enemyYnorth, enemyYsouth;
//unsigned char tileCenter;
//unsigned char enemyObsticleTrace;
//unsigned char barrier;
//unsigned char bob = 0;//used to print to screen
//unsigned char sue;//used to print to screen also
//unsigned char test;
//unsigned char scanx, scany;
//long scorearray[6] = {0,0,0,0,0,0};
// short horizonal [3] = {0,0,0};
// short vertical [3] = {0,0,0};


///////////////////////////////////
//  VARIABLES TAGGED for REMOVAL //
///////////////////////////////////


////////////////////////////////////
//         GLOBAL VARIABLES       //
////////////////////////////////////

This of course needs to be done periodically and I’ll be going into radio silence every time I do it. In the end however, it will be worth the trouble.

Happy Coding.

Advertisements

Author: andydansby

I'm a hobbyist coder working with the ZX Spectrum. Living in New York state near the Syracuse area. I grew up in Virgina. The first computer my parents bought for me was a Timex Sinclair 2068.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s