There are 16*16 == 256 combinations of two characters corresponding to the 256 possible 8-bit patterns a byte could hold.

The 32 characters underlined by the red brackets represent the 16 bytes of the file. (Two characters are printed for each byte.)

There is nothing in the file
between the four bytes of each integer.
The bytes follow one after another with nothing special
separating the last byte of one integer from the first byte
of the next.
I knew where to draw the red brackets because
I knew that each `int`

was four bytes long.
Without knowing this,
I would not know which bytes should be
grouped together.

The first `int`

written contains a zero.
The pattern above the first bracket shows the
32-bit pattern that represents the value zero.
Each "0" in the dump stands for four bits with
value zero,
so the 32-bit pattern for zero is
`00000000000000000000000000000000`

Don't worry about these details; the idea is to show that the file contains bit patterns corresponding to the way integers are represented inside the processor. You will get much more of this stuff in a course in assembly language.

The second group is a 32-bit representation of one. The third group represents 255. The hexadecimal character "F" represents four bits with value one. So the value 255 is represented by 24 zero bits followed by 8 one bits.

The last `int`

holds minus one.
What is the 32-bit representation of minus one?