Binary to Gray Code Java

BuckGup · November 20, 2019

I am still trying to write an algorithm to find the fastest possible combination of switch presses on the worst possible case for N number of switches. I have the psuedo code to figure it out but I am having trouble taking the initial random state of the switches, which I have in an int array, and making that in binary somehow.

Here is all the code but it is super confusing

Spoiler


import java.util.Scanner;
import java.util.Random;
import java.io.*;


public class lightbulb {


    public static void main(String[] args) {

        Random rand = new Random();
        boolean lightSwitchState = false;
        Scanner userIn = new Scanner(System.in);
        System.out.println("How many switches would you like?");
        int numSwitches = userIn.nextInt();
        int[] lightBulbArray = new int[numSwitches];
        int[] binaryArray = new int[numSwitches];
        char[] binaryChars;

        int counter = 0;

        while (counter != numSwitches) { //fills the array with random values
            lightBulbArray[counter] = rand.nextInt(2);
            counter++;
        }


        for (int i = 0; i < lightBulbArray.length; i++) {
            System.out.print(lightBulbArray[i]);
        }

        if (isOne(lightBulbArray)) {
            lightSwitchState = true;
            System.out.println("The light bulb is on");
            System.out.println("It took zero tries!");
            return;
        }

        for(int i = 0; i <lightBulbArray.length; i++){//make a copy of the array
            binaryArray[i] = lightBulbArray[i];
        }

        System.out.println("\nStart of sequence");


        //make a copy of the lightbulb array and keep adding one and compare the gray code from the previous to current to see what changed
        //then whatever had changed flip that in the lighbulb array and test to see if all are 1


        for(int j = 0; j < Math.pow(2, numSwitches); j++){

            String addOne = Integer.toBinaryString(j);



        }





//        for (int j = 0; j < Math.pow(2, numSwitches); j++) {
//
//            String binaryString = Integer.toBinaryString(j); //converts the num of switches to binary
//            binaryChars = binaryString.toCharArray(); //converts String to char array for use in loop later
//            // reverseArray(lightBulbArray, binaryChars.length);
//
//            //System.out.println(binaryChars);
//
//            binaryToGray(binaryChars);
//            //System.out.println("Binary to Gray");
//            //System.out.println(binaryToGray(binaryChars));
//
//                for (int p = binaryChars.length - 1; p >= 0; p--) {
//
//                    if (binaryChars[p] == 49) {
//
//                        lightBulbArray[p] = 1 - lightBulbArray[p];//flips the switch in the original array
//
//                        if (isOne(lightBulbArray)) {
//                            lightSwitchState = true;
//                            System.out.println("The light bulb is on");
//                            System.out.println("It took " + j + " tries"); //use Grays code for the position of the number flipped
//                            return;
//                        }
//
//                    }
//                }
//            }


        }

    private static boolean isOne(int[] lightBulbArray) {
        boolean lightSwitchState;
        boolean isOne = true;
        for (int i = 0; i < lightBulbArray.length; i++) {//checks to see if the switches are all on without flipping a switch
            if (lightBulbArray[i] != 1) {
                isOne = false;
            }
        }
        return isOne;
    }

    public static char[] binaryToGray(char[] binary) {

        //System.out.println("This is binary");
//        for(int j = 0; j < binary.length -1; j++){
//            System.out.println(binary[j]);
//        }
        char gray[] = {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};
        gray[0] = binary[0];
        char a;
        char b;
        int c;
        for (int i = 0; i < binary.length - 1; i++) {
            a = binary[i];
            b = binary[i + 1];

            //System.out.println("A: " + Character.getNumericValue(a) + "\n");
            //System.out.println("B: " + Character.getNumericValue(b) + "\n");

            c = (Character.getNumericValue(b)) ^ (Character.getNumericValue(a));
            //System.out.println((char)c + 48);
            gray[i + 1] = (char)(c + 48);
        }

        return gray;
    }


    static void reverseArray(int a[], int n) {
        int[] b = new int[n];
        int j = n;
        for (int i = 0; i < n; i++) {
            b[j - 1] = a[i];
            j = j - 1;
        }

    }


}

I am just trying to be able to add 1 continuously to a binary number. So for 0110 add 1 would be 0111. But I start with an array of some random order of 1111 ints. Can I just treat this as binary without any conversions then use Integer.toBinaryString() for counting in a loop? Will adding two strings that are binary result in binary? Thanks

Eigenvektor · November 20, 2019

Can you explain a bit more about what the code is supposed to do?

Quote

I am still trying to write an algorithm to find the fastest possible combination of switch presses on the worst possible case for N number of switches.

Switch presses to do what exactly; what is the goal of these switch presses?

I can see you create an integer array and randomly fill that with 1s and 0s. You create a copy of it... and then you've lost me. You're converting that to a String for some reason and by gray code, I assume you're referring to https://en.wikipedia.org/wiki/Gray_code?

Also, what you you mean by strings that are binary? A String in Java is a character sequence. If you add (or rather, "concatenate") two Strings, you get a new String that is both strings appended to one another. Basically "a" + "b" = "ab". There is no such thing as a "binary string".

Franck · November 20, 2019

Typically gray code cover hexa positions only but can be scaled as long as you return to your 0 at the end of the sequence.

I don't quite grasp what you are trying to do but i would start by generating the gray code table first which is pretty easy then since it's ordered you can know exactly how many steps from one code to another as you are indexed. Probably a hastable or a list to store the table

straight_stewie · November 20, 2019

8 hours ago, BuckGup said:

I am just trying to be able to add 1 continuously to a binary number. So for 0110 add 1 would be 0111. But I start with an array of some random order of 1111 ints. Can I just treat this as binary without any conversions then use Integer.toBinaryString() for counting in a loop? Will adding two strings that are binary result in binary? Thanks

I gather that you're ostensibly trying to track a bank of switches, determine which ones are off and which ones are on. When all switches are on, you want to do some action. Is this correct?

BuckGup · November 20, 2019

3 minutes ago, straight_stewie said:

I gather that you're ostensibly trying to track a bank of switches, determine which ones are off and which ones are on. When all switches are on, you want to do some action. Is this correct?

The idea is when all switches are on they turn a light bulb on. But you don't know what they started at. I am designing it for the worst case so you sorta have to know what the switches started out as but the logic applies to any combination of the switches being on and off. It will just take less time to get them all to be on

BuckGup · November 20, 2019

8 hours ago, Eigenvektor said:

Can you explain a bit more about what the code is supposed to do?

Switch presses to do what exactly; what is the goal of these switch presses?

I can see you create an integer array and randomly fill that with 1s and 0s. You create a copy of it... and then you've lost me. You're converting that to a String for some reason and by gray code, I assume you're referring to https://en.wikipedia.org/wiki/Gray_code?

Also, what you you mean by strings that are binary? A String in Java is a character sequence. If you add (or rather, "concatenate") two Strings, you get a new String that is both strings appended to one another. Basically "a" + "b" = "ab". There is no such thing as a "binary string".

I have a char array of 10101 and I want to be able to add 1 to it in binary. How would I go about doing that? As adding 1 to 10101 would just do 101011

straight_stewie · November 20, 2019

9 minutes ago, BuckGup said:

The idea is when all switches are on they turn a light bulb on. But you don't know what they started at. I am designing it for the worst case so you sorta have to know what the switches started out as but the logic applies to any combination of the switches being on and off. It will just take less time to get them all to be on

Ok great. I'm still a little confused about the point of your algorithm. It is admittedly a little difficult for me to understand your goal by reading through your code.

I'm wondering if I understand correctly:

Viewed as a black box, your algorithm needs to take in an array of integers, each representing the state of a switch. When an integer in the array is "1" the switch is on, otherwise it is off. Your algorithm needs to find the number of changes necessary to make all integers in the array be a "1", and return that number to the user?

Are we trying to determine the number of bit changes necessary over all integers in the array, or the total number of integers that need to be changed in the array?

BuckGup · November 20, 2019

34 minutes ago, straight_stewie said:

Ok great. I'm still a little confused about the point of your algorithm. It is admittedly a little difficult for me to understand your goal by reading through your code.

I'm wondering if I understand correctly:

Viewed as a black box, your algorithm needs to take in an array of integers, each representing the state of a switch. When an integer in the array is "1" the switch is on, otherwise it is off. Your algorithm needs to find the number of changes necessary to make all integers in the array be a "1", and return that number to the user?

Are we trying to determine the number of bit changes necessary over all integers in the array, or the total number of integers that need to be changed in the array?

Yeah so you have the correct idea. I am trying to determine the number of switch flips it took to turn on the light bulb. The point of the gray code is you are only flipping one switch at a time. So by comparing two gray codes for consecutive binary numbers they only differ by one bit. The bit that changed tells us the index of which switch to flip in the original switch array.

straight_stewie · November 20, 2019

4 minutes ago, BuckGup said:

Yeah so you have the correct idea. I am trying to determine the number of switch flips it took to turn on the light bulb. The point of the gray code is you are only flipping one switch at a time. So by comparing two gray codes for consecutive binary numbers they only differ by one bit. The bit that changed tells us the index of which switch to flip in the original switch array.

I'm confused about the meaning and significance of "flipping one switch at a time"? Or in other words: Why can't you just loop through the array and count how many non-zero ints there are?

BuckGup · November 20, 2019

12 minutes ago, straight_stewie said:

I'm confused about the meaning and significance of "flipping one switch at a time"? Or in other words: Why can't you just loop through the array and count how many non-zero ints there are?

Because while in my case I know the starting state the general idea is you don't know. So to check every possible combination you need to go one switch at a time. Sure you could randomly flip them all first try and that happens to work and would be fastest but it doesn't follow an algorithm. Also maybe you are thinking of just doing a pattern so for 1000 you flip the first 0000 then the second 1100 then the third 1010 fourth 1001. Then do first 0100 and second then second and third 1110 and so on. This would only work if they start at 0000 and the pattern has to scale for N number of switches.

straight_stewie · November 20, 2019

6 minutes ago, BuckGup said:

Because while in my case I know the starting state the general idea is you don't know. So to check every possible combination you need to go one switch at a time.

But the on and off states are known.

A single switch is represented by an integer. If the integer is "1", the switch is on. Otherwise, the switch is off.

You could just do the below to count how many are off:

int offCounter = 0;
foreach mySwitch in switches 
{
  if (mySwitch != 1)
    offCounter ++;
}

return offCounter;

Or am I still missing some key piece of information here?

Eigenvektor · November 20, 2019

8 hours ago, BuckGup said:

I have a char array of 10101 and I want to be able to add 1 to it in binary. How would I go about doing that? As adding 1 to 10101 would just do 101011

Took me a little while to understand what you were asking. You want to perform an addition of the two numbers represented by the binary values "10101" and "1". When you simply add (append) the number "1" to your array you get "101011" (obviously).

Here's a method that can perform a mathematical addition of two "bit" arrays:

private boolean[] add(final boolean[] augend, final boolean[] addend) {
	final boolean[] result = new boolean[Math.max(augend.length, addend.length)];
	final int len = Math.min(augend.length, addend.length);
	boolean carryBit = false;

	for (int n = 0; n < len; n++) {
		final boolean augendBit = augend[augend.length - 1 - n];
		final boolean addendBit = addend[addend.length - 1 - n];

		result[result.length - 1 - n] = (augendBit ^ addendBit) ^ carryBit;
		carryBit = (augendBit & addendBit) | (augendBit & carryBit) | (addendBit & carryBit);
	}

	return result;
}

I used boolean[] instead of char[], because that's in my opinion better suited to represent bits and/or switches. The method doesn't properly handle overflow, so for example [1,1,1,1] + [1] = [0,0,0,0]. For any other values it should work as expected.

Test cases:

Spoiler


	private void print(final boolean[] bits) {
		for (final boolean bit : bits) {
			System.out.print(bit ? 1 : 0);
		}
		System.out.println();
	}

	private boolean[] intToBitArray(final int value) {
		final boolean[] bits = new boolean[32];
		for (int n = 0; n < 32; n++) {
			bits[31 - n] = (value & (1 << n)) != 0;
		}
		return bits;
	}

	private int bitArrayToInt(final boolean[] bits) {
		if (bits.length > 32) {
			throw new IllegalArgumentException("Number of bits is too large for an int");
		}
		int value = 0;

		for (final boolean bit : bits) {
			value = value << 1;
			value |= (bit ? 1 : 0);
		}
		return value;
	}

	private boolean[] add(final boolean[] augend, final boolean[] addend) {
		final boolean[] result = new boolean[Math.max(augend.length, addend.length)];
		final int len = Math.min(augend.length, addend.length);
		boolean carryBit = false;

		for (int n = 0; n < len; n++) {
			final boolean augendBit = augend[augend.length - 1 - n];
			final boolean addendBit = addend[addend.length - 1 - n];

			result[result.length - 1 - n] = (augendBit ^ addendBit) ^ carryBit;
			carryBit = (augendBit & addendBit) | (augendBit & carryBit) | (addendBit & carryBit);
		}

		return result;
	}

	@Test
	public void testAddition_15_plus_1_equals_16() {
		final boolean[] augend = intToBitArray(15);
		final boolean[] addend = intToBitArray(1);
		final boolean[] result = add(augend, addend);

		print(augend);
		print(addend);
		print(result);

		assertThat(bitArrayToInt(result)).isEqualTo(16);
	}

	@Test
	public void testAddition_3_plus_3_equals_6() {
		final boolean[] augend = intToBitArray(3);
		final boolean[] addend = intToBitArray(3);
		final boolean[] result = add(augend, addend);

		print(augend);
		print(addend);
		print(result);

		assertThat(bitArrayToInt(result)).isEqualTo(6);
	}

	@Test
	public void testAddition_128_plus_127_equals_255() {
		final boolean[] augend = intToBitArray(128);
		final boolean[] addend = intToBitArray(127);
		final boolean[] result = add(augend, addend);

		print(augend);
		print(addend);
		print(result);

		assertThat(bitArrayToInt(result)).isEqualTo(255);
	}

	@Test
	public void testAddition_98_plus_2_equals_100() {
		final boolean[] augend = intToBitArray(98);
		final boolean[] addend = intToBitArray(2);
		final boolean[] result = add(augend, addend);

		print(augend);
		print(addend);
		print(result);

		assertThat(bitArrayToInt(result)).isEqualTo(100);
	}

	@Test
	public void testAddition_Max_plus_1_equals_0() {
		final boolean[] augend = intToBitArray(-1);
		final boolean[] addend = intToBitArray(1);
		final boolean[] result = add(augend, addend);

		print(augend);
		print(addend);
		print(result);

		assertThat(bitArrayToInt(result)).isEqualTo(0);
	}

wasab · November 21, 2019

11 hours ago, BuckGup said:

I have a char array of 10101 and I want to be able to add 1 to it in binary. How would I go about doing that? As adding 1 to 10101 would just do 101011

you do a bitwise or if all you want to do is to flip a bit to 1

char c = 0x030; // ascii 0
c = (char) (c | 0x01); // now it is ascii 1

http://www.asciitable.com/

convert them to binary and you will see the first least significant bit is flipped.

to flip the second bit, set all other bits to 0 and turn that 2nd bit to 1 and then do a bitwise or. c | 0x02 or c | 0b010

Edit: looking at what you want to do, you will also need to shift the bit. so do c = c << 1 before bitwise or.

if char c = 0b010101

then c = c << 1 = 0b101010

and then c | 0b01 would be 0b101011

BuckGup · November 21, 2019

1 hour ago, wasab said:
you do a bitwise or if all you want to do is to flip a bit to 1
char c = 0x030; // ascii 0
c = (char) (c | 0x01); // now it is ascii 1
http://www.asciitable.com/

convert them to binary and you will see the first least significant bit is flipped.

to flip the second bit, set all other bits to 0 and turn that 2nd bit to 1 and then do a bitwise or. c | 0x02 or c | 0b010

Edit: looking at what you want to do, you will also need to shift the bit. so do c = c << 1 before bitwise or.

if char c = 0b010101

then c = c << 1 = 0b101010

and then c | 0b01 would be 0b101011

Okay it might take a second to implement this but for now I have just been using the integer value and adding an int 1 then converting that to a binary string. Only issue I have now is sometimes the int value converted to binary is less than the number of switches I am suppose to have. For example I randomly get an int between 2^n - 1 number of switches. Lets use 4 for this example. So it can be some random integer from 0-15 well Integer.toBinaryString(1) = 1 and not 0001. So I am trying to pad it with zeros. I could use

String.format("%5s", Integer.toBinaryString(data)).replace(' ', '0');

but the %5s needs to be dynamic and change which it can't do. So I was thinking I could just test to see if the array length is less than that of the number of switches and then add zeros to the char array and then flip it.

wasab · November 21, 2019

26 minutes ago, BuckGup said:
Okay it might take a second to implement this but for now I have just been using the integer value and adding an int 1 then converting that to a binary string. Only issue I have now is sometimes the int value converted to binary is less than the number of switches I am suppose to have. For example I randomly get an int between 2^n - 1 number of switches. Lets use 4 for this example. So it can be some random integer from 0-15 well Integer.toBinaryString(1) = 1 and not 0001. So I am trying to pad it with zeros. I could use
String.format("%5s", Integer.toBinaryString(data)).replace(' ', '0');
but the %5s needs to be dynamic and change which it can't do. So I was thinking I could just test to see if the array length is less than that of the number of switches and then add zeros to the char array and then flip it.

Why would you need to see the integer in its binary representation in the first place? Do you actually need to print it out to console? Most humans would read numbers in powers of 10 instead of powers of 2s like a computer. How many bits in total do you actually want to see? 4 of them?

BuckGup · November 21, 2019

5 minutes ago, wasab said:

Why would you need to see the integer in its binary representation in the first place? Do you actually need to print it out to console? Most humans would read numbers in powers of 10 instead of powers of 2s like a computer. How many bits in total do you actually want to see? 4 of them?

Yeah I need to print out the binary of it. I think I solved it by doing what I said.

 char[] reverseLightBulbCharArray = new char[lightBulbCharArray.length];

        if (lightBulbCharArray.length < numSwitches) {

            char[] lightBulbCharArrayExtended = new char[numSwitches];

            System.out.println("The Stuff below");
            System.out.println(lightBulbCharArrayExtended);

            for (int c = 0; c < numSwitches; c++) {

                //lightBulbCharArray[]

            }


            int howMany = numSwitches - lightBulbCharArray.length;
            counter = lightBulbCharArray.length + 1;

            if (lightBulbCharArray.length == 0) {
                counter = lightBulbCharArray.length;
                for (int i = 0; i < howMany; i++) {
                    lightBulbArray[counter] = 0;
                    counter++;
                }
            } else {
                for (int i = 0; i < howMany; i++) {
                    lightBulbCharArray[counter] = 0;
                    counter++;
                }
            }

            int i = lightBulbCharArray.length - 1, v = 0;
            while (i >= 0) {
                reverseLightBulbCharArray[v] = lightBulbCharArray[i];
                i--;
                v++;
            }
        }

I am just trying to work though the logic now by copying the data from the original array to another in reverse order that was initialized with all zeros. Anything from int howMany down is now useless as I was trying to fill out a char array with zeros but something has to be there originally so it doesn't matter

wasab · November 21, 2019

3 minutes ago, BuckGup said:

I am just trying to work though the logic now by copying the data from the original array to another in reverse order that was initialized with all zeros. Anything from int howMany down is now useless as I was trying to fill out a char array with zeros but something has to be there originally so it doesn't matter

    	char charOfBinaryZero = '\0';
        System.out.println("binary char of zero: " + Integer.toBinaryString(charOfBinaryZero));
        char fourthBitFlipped = (char) (charOfBinaryZero | 0b01000);
        System.out.println("fourthBitFlipped: " + Integer.toBinaryString(fourthBitFlipped));
        char shiftOverOne =  (char) (fourthBitFlipped <<= 1);
        String binaryString = Integer.toBinaryString(shiftOverOne);
        System.out.println("shifted left 1: " + binaryString);
        String zero = "0";
        String paddedToEightBits = zero.repeat(8 - binaryString.length()) + binaryString;
        System.out.println("after padded to 8 bits: " + paddedToEightBits);

Try the examples above. I am sure you can figure out the rest.

BuckGup · November 21, 2019

10 minutes ago, wasab said:


    	char charOfBinaryZero = '\0';
        System.out.println("binary char of zero: " + Integer.toBinaryString(charOfBinaryZero));
        char fourthBitFlipped = (char) (charOfBinaryZero | 0b01000);
        System.out.println("fourthBitFlipped: " + Integer.toBinaryString(fourthBitFlipped));
        char shiftOverOne =  (char) (fourthBitFlipped <<= 1);
        String binaryString = Integer.toBinaryString(shiftOverOne);
        System.out.println("shifted left 1: " + binaryString);
        String zero = "0";
        String paddedToEightBits = zero.repeat(8 - binaryString.length()) + binaryString;
        System.out.println("after padded to 8 bits: " + paddedToEightBits);

Try the examples above. I am sure you can figure out the rest.

Okay I tried it out and can see what it is doing. Two questions, does the 0b01000 scale for each bit so if I wanted to flip the 2nd I would do 0b00010 and how would you start not at zero

wasab · November 21, 2019

22 minutes ago, BuckGup said:

if I wanted to flip the 2nd I would do 0b00010

Yes.

Edit: by flipped I meant setting it to 1. If you want to invert it, you would do xor

22 minutes ago, BuckGup said:

how would you start not at zero

Char c = 255. All the bits would be 1.

Or you can do char c = 0b11111111 if you want to get low level.

BuckGup · November 21, 2019

30 minutes ago, wasab said:

Yes.

Edit: by flipped I meant setting it to 1. If you want to invert it, you would do xor

Char c = 255. All the bits would be 1.

Or you can do char c = 0b11111111 if you want to get low level.

So then if I picked a random value between a specified range the user inputs I could just fill a string with it in binary than add that to 0b and declare the character c as it?

wasab · November 21, 2019

16 minutes ago, BuckGup said:

So then if I picked a random value between a specified range the user inputs I could just fill a string with it in binary than add that to 0b and declare the character c as it?

What you mean by that? Show me the snippet of code you are thinking of.

straight_stewie · November 21, 2019

10 hours ago, BuckGup said:

Okay I tried it out and can see what it is doing. Two questions, does the 0b01000 scale for each bit so if I wanted to flip the 2nd I would do 0b00010 and how would you start not at zero

Oh. You're just trying to pack individual bits into a byte. This is why I was really confused. That's called bit masking, and it's a technique as old as time itself. (older video games used bit masking so that they only had to redraw the portions of the screen that actually changed. This, in combination with blitting enabled weak hardware to perform graphical feats that seemed ahead of their time).

Here are some examples of basic bit field operations using bitmasks.

// Set the nth bit in a byte
byte SetBit(data, n)
{
  byte mask = 1 << n;
  return data | mask;
}

// Unset the nth bit in a byte
byte UnsetBit(data, n)
{
  byte mask = ~(1 << n);
  return data & mask;
}

// Toggle the nth bit in a byte
byte ToggleBit(data, n)
{
  byte mask = 1 << n;
  return data ^ mask;
}

// See if the nth bit is set
bool IsBitSet(byte, n)
{
  byte mask = 1 << n;
  return (bool)(byte & mask);
}

// See if the nth bit is not set
bool IsBitUnset(byte, n)
{
  byte mask = 1 << n;
  byte = ~byte;
  return (bool)(byte & mask);
}

I would recommend not using char as a replacement for a numeric type in Java. Java uses 16 bit unicode chars, and as you've discovered, that's going to require all kinds of special handling where you are casting all over the place and such. The use of Char as a numeric type came about in C/C++ where the default character encoding is ASCII, and internally is just recognized as a byte, so all byte operations are valid on chars.

If, instead, we just use an int to represent our binary data, then we can just do this to print it's binary representation to the console:

System.out.println("Your data is: " + Integer.toBinaryString(num));

I see no value in messing around with converting your data to char and back again just to have the interpreter convert it to a string and then to a char array for final display. Just leave your data as whatever numeric type you've deemed appropriate, until the very last moment when you want to display it. Then do as little as possible to display it with the formatting you want.

As an aside, if you get tired of reading 32 bit binary numbers to debug your algorithm, there is a more generalized integer to string conversion:

Integer.toString(number, base);

// Where number is the integer you want to convert and 
// base is the numeric base you want it represented as.
// 2 for binary, 8 for octal, 10 for decimal, and 16 for hexadecimal.

If you find bit twiddling as interesting as I do, here are some resources for further reading:

Sign In

Binary to Gray Code Java

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites

Link to post

Share on other sites

Link to comment

Share on other sites