How to initialize multiple structures at an arbitrary point of an array in C?

I have a structure in C defined by

struct problem_spec_point {
        int point_no;
        double x;
        double y;
        int bc;
};

I have an array of these structures of length 6, with the first four structures defined explicitly on initialization.

static struct point points[6] =
    {
        {0, 1, 2, 5},
        {0, 1, 2, 6},
        {0, 1, 2, 7},
        {0, 1, 2, 8},
    };

I can add the 5th and 6th structures later:
points[4] = (struct point) {0,1,2,12};
points[5] = (struct point) {3,3,3,3};

But suppose that I wanted to add these two (or multiple) consecutive structures, all at once.
Something like

points[4] = {(struct point) {0,1,2,12}, (struct point) {3,3,3,3},};

Is there any such way to do this?

Obviously I tried the syntax listed above.

For context, in reality my code has an array of length 3n+6. I have a for-loop assigning the first 3n structures their values, but the last 6 have a different, odd pattern.

for(int i = 0; i < 3n; i++)
{
 point[i] = stuff;
}

//odd points here at end of array

I could switch the order and do some indexing changes:

static struct point points[3n+6] = 
{
  last points first
}

for(int i = 6; i < 3n+6, i++
{
  point[i]=stuff;
}

But I don't want to. I am not super familiar with C, and I am curious.

This is my first post, so please forgive me if I did not follow the normal format.

The best way is likely just to type it out in plain, readable code:

points[4] = (struct point) {0,1,2,12};
points[5] = (struct point) {3,3,3,3};

Alternatively for big intervals with the same value etc, use memcpy. Perhaps something along the lines of this:

#include <string.h>

void add_points (struct point* points, const struct point* val, size_t from, size_t to)
{
  for(size_t i=from; i<=to; i++)
  {
    memcpy(&points[i], val, sizeof(struct points));
  }
}


// usage example: assign {3,3,3,3} from index 4 to index 5

add_points(points, &(struct point){3,3,3,3}, 4, 5);

(This code can be optimized slightly by using restrict pointers.)

Lundin rightly told that you can use memcpy. He didn't explicitly mention that you can reformulate your attempt for different values

points[4] = {(struct point) {0,1,2,12}, (struct point) {3,3,3,3},};

with memcpy like

	memcpy(points+4, (struct point []){ {0,1,2,12}, {3,3,3,3} },
			  sizeof (struct point [2]));


</details>