Binary representation of an unsigned long long - c

Question

I am trying to get the binary form of an unsigned long long and store each bit of it in an array.
I have an input file like this:
0000000000000000 0000000000000000
FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF
3000000000000000 1000000000000001
where each entry is a 64-bit integer represented in hex. I am using an unsigned long long to hold this value then iterating over the bits and attempting to store them in an array, but some of the arrays have bits in the wrong position.
Here is what I have:
char key_in[17];
char plaintext_in[17];
//64-bit long variables to hold the 64-bit hex values in the input file
unsigned long long key, plaintext;
//I read an entry from the file with fscanf
fscanf(infile,"%s %s",&key_in, &plaintext_in)
//convert the numbers from hex to unsigned long long with strtoull
key = strtoull(key_in, NULL, 16);
plaintext = strtoull(plaintext_in, NULL, 16);
//initialize arrays with 64 positions that will hold the
//binary representation of the key and plaintext
int key_arr[64];
int pt_arr[64];
//fill the arrays with the binary representations
//of the plaintext and the key
int64_to_bin_array(key, key_arr, 64);
int64_to_bin_array(plaintext, pt_arr, 64);
//print both arrays
printArray(key_arr, 64);
printArray(pt_arr, 64);
here are the functions I created int64_to_bin_array and printArray:
/* Converts from an unsigned long long into an array of
integers that form the binary representation of a */
void int64_to_bin_array(unsigned long long a, int *b, int length)
{
int i;
for(i = 0; i < length; i++)
{
*(b+i) = (a >> i) & 1; //store the ith bit in b[i]
}
}
/* prints a one-dimensional array given
a pointer to it, and its length */
void printArray(int *arr, int length)
{
int i;
for(i = 0; i < length; i++)
{
printf("%d ", *(arr + i));
}
printf("\n\n");
}
When I print the array for the third input however, I receive an incorrect result:
input (in hex):
1. 3000000000000000 2. 1000000000000001
output (in binary):
1 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00001100
2 10000000 00000000 00000000 00000000 00000000 00000000 00000000 00001000
Can anyone see where I have made a mistake?
EDIT
I get the correct output after both reading and printing in reverse, but my problem is I need the array to have its most significant byte first so I can manipulate it. Any ideas how that can be done? Would I have to reassign it to a new array and copy the elements in reverse?

Answer 1

Try reading it the other way around. Let's take the last octet:
00001100 = 0x0C
00110000 = 0x30 <---
That corresponds yo your first first octet, 0x30.
For the second number:
00001000 = 0x08
00010000 = 0x10 <---
That corresponds to your first first octet, 0x10.
You'll probably get what you expect if you print it like this:
for(i = length - 1; i >= 0; i--)