Language: C

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define INFINITY 2000000000;

struct data{

  char character[10];
  int value;

};

struct data Ldata[50010];
struct data Rdata[50010];
struct data inputdata1[100010];
struct data inputdata1[100010];

void quicksort(struct data[],int,int,int);
int partition(struct data[],int,int,int);
void margesort(struct data[],int,int);
void marge(struct data[],int,int,int);

int main(){

  int sumdata;
  int i,j,flag = 0;
  /*struct data *inputdata1,*inputdata2;*/

  scanf("%d",&sumdata);

  inputdata1 = malloc(sizeof(struct data) * sumdata);
  inputdata2 = malloc(sizeof(struct data) * sumdata);

  for(i = 0; i < sumdata; i++){

    scanf("%s",inputdata1[i].character);
    scanf("%d",&inputdata1[i].value);
    inputdata2[i] = inputdata1[i];
  }

  quicksort(inputdata1,sumdata,0,sumdata-1);
  margesort(inputdata2,0,sumdata);

  for( i = 0; i < sumdata;i++){

    if(flag == 1){

      break;

    }

    else if(strcmp(inputdata1[i].character,inputdata2[i].character) != 0){

      flag = 1;

    }
  }

 if(flag == 1){
      printf("Not stable\n");

    }

    else{
      printf("Stable\n");

    }

  for(i = 0; i < sumdata; i++){

   
    printf("%s %d\n",inputdata1[i].character,inputdata1[i].value);

  }

  return 0;

}

void quicksort(struct data inputdata1[],int sumdata,int i,int j){

  int index;

  if(i < j){

    index = partition(inputdata1,sumdata,i,j);

    quicksort(inputdata1,sumdata,0,index -1);
    quicksort(inputdata1,sumdata,index+ 1,j);

  }
}

int partition(struct data inputdata1[],int sumdata,int left, int right){

  int i,j,index;
  struct data change;
  i = left -1 ;
  j = 0;

  index = inputdata1[right].value;

  for(j = left; j < right; j++){

    if(index >= inputdata1[j].value){
      
      i = i + 1;
      change = inputdata1[i];
      inputdata1[i] = inputdata1[j];
      inputdata1[j] = change;

    }


  }

  change = inputdata1[right];
  inputdata1[right] = inputdata1[i+1];
  inputdata1[i+1] = change;

  return i+1;
}
/*   else{*/



/*change = inputdata1[*/
  /*  while(y != j){

    if(index >= inputdata1[y].value){

      change = inputdata1[x];
      inputdata1[x] = inputdata1[y];
      inputdata1[y] = change;

      x = x + 1;
      y = y + 1;

    }

    else if(index < inputdata1[y].value){

      y = y + 1;

    }

  }

  change = inputdata1[j];
  inputdata1[j] = inputdata1[x];
  inputdata1[x] = change;

  return x;

  }*/

void margesort(struct data inputdata2[],int left,int right){

  int mid;

  if(left + 1 < right){

    mid = (left + right) /2;

    margesort(inputdata2,left,mid);
    margesort(inputdata2,mid,right);

    marge(inputdata2,left,mid,right);

  }

}

void marge(struct data inputdata2[],int left,int mid,int right){

  int i,j,k;
  int Lsumdata,Rsumdata;

  Lsumdata = mid - left;
  Rsumdata = right - mid;

  for(i = 0; i < Lsumdata; i++){

    Ldata[i] = inputdata2[left +i];

  }

  for(i = 0; i < Rsumdata; i++){

    Rdata[i] = inputdata2[mid + i];

  }

  Ldata[Lsumdata].value = INFINITY;
  Rdata[Rsumdata].value = INFINITY;

  i = 0;
  j = 0;

  for(k = left; k < right; k++){

    if(Ldata[i].value <= Rdata[j].value){

      inputdata2[k] = Ldata[i];
      i = i + 1;
    }

    else if(Ldata[i].value > Rdata[j].value){

      inputdata2[k] = Rdata[j];

      j = j + 1;

    }

  }

}

Compiler output:
main.c: In function 'main':
main.c:31:14: error: assignment to expression with array type
   31 |   inputdata1 = malloc(sizeof(struct data) * sumdata);
      |              ^
main.c:32:3: error: 'inputdata2' undeclared (first use in this function); did you mean 'inputdata1'?
   32 |   inputdata2 = malloc(sizeof(struct data) * sumdata);
      |   ^~~~~~~~~~
      |   inputdata1
main.c:32:3: note: each undeclared identifier is reported only once for each function it appears in