Requested partition: <partno=0,start=2048,size=2048>
Requested partition: <partno=1,start=6144,size=2048>
Requested partition: <partno=2,start=8192,size=2048>
Requested partition: <partno=3,start=12288,size=2048>
Requested partition: <partno=4,start=14336,size=2048>
Created a new <removed>.
Created a new <removed>.
Created a new <removed>.
Created a new <removed>.
Created a new <removed>.
Created a new <removed>.
Disk <removed>: 15 MiB, 15728640 bytes, 30720 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / <removed> bytes
Disklabel type: gpt
Disk identifier: <removed>

Device             Start   End Sectors Size Type
<removed>1  2048  4095    2048   1M Linux filesystem
<removed>2  6144  8191    2048   1M Linux filesystem
<removed>3  8192 10239    2048   1M Linux filesystem
<removed>4 12288 14335    2048   1M Linux filesystem
<removed>5 14336 16383    2048   1M Linux filesystem
