Language: C

include<stdio.h>
#define MAX 100000
#define SENTINEL 2000000000

struct Card{
  char suit;
  int value;
};

struct Card L[MAX/2+2], R[MAX/2+2];

void merge(struct Card A[], int n, int left, int mid, int right){

  int i, j, k;
  int n1 = mid - left;
  int n2 = right - mid;

  for(i=0; i<n1; i++){
    L[i] = A[left+1];
  }
  for(i=0; i<n2; i++){
    R[i] = A[mid+i];
  }

  L[n1].value = R[n2].value = SENTINEL;
  i = j = 0;

  for(k=left; k<right; k++){
    if(L[i].value <= R[j].value){
      A[k] = L[i++];
    }
    else{
      A[k] = R[j++];
    }
  }

}


void mergeSort(struct Card A[], int n, int left, int right){

  int mid;

  if(left+1 < right){
    mid = (left+right)/2;
    mergeSort(A, n, left, mid);
    mergeSort(A, n, mid, right);
    merge(A, n, left, mid, right);
  }

}

int partition(struct Card A[], int n, int p, int r){

  int i, j;
  struct Card t, x;
  x = A[r];
  i = p-1;

  for(j=p; j<r; j++){
    if(A[j].value <= x.value){
      i++;
      t = A[i];
      A[i] = A[j];
      A[j] = t;
    }
  }

  t = A[i+1];
  A[i+1] = A[r];
  A[r] = t;

  return i+1;

}


void quickSort(struct Card A[], int n, int p, int r){

  int q;

  if(p<r){
    q = partition(A, n , p, r);
    quickSort(A, n, p, q-1);
    quickSort(A, n, q+1, r);
  }

}

int main(){

  int n, i, v;
  struct Card A[MAX], B[MAX];
  char S[10];
  int stable=1;

  scanf("%d",&n);

  for(i=0; i<n; i++){
    scanf("%s %d", S, &v);
    A[i].suit = B[i].suit = S[0];
    A[i].value = B[i].value = v;
  }

  mergeSort(A, n, 0, n);
  quickSort(B, n, 0, n-1);

  for(i=0; i<n; i++){
    if(A[i].suit != B[i].suit){
      stable = 0;
    }
  }

  if(stable==1){
    printf("Stable\n");
  }
  else{
    printf("Not stable\n");
  }

  for(i=0; i<n; i++){
    printf("%c %d\n", B[i].suit, B[i].value);
  }

  return 0;
}

Compiler output:
main.c:1:8: error: expected '=', ',', ';', 'asm' or '__attribute__' before '<' token
    1 | include<stdio.h>
      |        ^
main.c:10:13: error: array type has incomplete element type 'struct Card'
   10 | struct Card L[MAX/2+2], R[MAX/2+2];
      |             ^
main.c:10:25: error: array type has incomplete element type 'struct Card'
   10 | struct Card L[MAX/2+2], R[MAX/2+2];
      |                         ^
main.c:12:24: error: array type has incomplete element type 'struct Card'
   12 | void merge(struct Card A[], int n, int left, int mid, int right){
      |                        ^
main.c:40:28: error: array type has incomplete element type 'struct Card'
   40 | void mergeSort(struct Card A[], int n, int left, int right){
      |                            ^
main.c: In function 'mergeSort':
main.c:46:15: error: type of formal parameter 1 is incomplete
   46 |     mergeSort(A, n, left, mid);
      |               ^
main.c:47:15: error: type of formal parameter 1 is incomplete
   47 |     mergeSort(A, n, mid, right);
      |               ^
main.c:48:11: error: type of formal parameter 1 is incomplete
   48 |     merge(A, n, left, mid, right);
      |           ^
main.c: At top level:
main.c:53:27: error: array type has incomplete element type 'struct Card'
   53 | int partition(struct Card A[], int n, int p, int r){
      |                           ^
main.c: In function 'partition':
main.c:56:15: error: storage size of 't' isn't known
   56 |   struct Card t, x;
      |               ^
main.c:56:18: error: storage size of 'x' isn't known
   56 |   struct Card t, x;
      |                  ^
main.c: At top level:
main.c:78:28: error: array type has incomplete element type 'struct Card'
   78 | void quickSort(struct Card A[], int n, int p, int r){
      |                            ^
main.c: In function 'quickSort':
main.c:83:19: error: type of formal parameter 1 is incomplete
   83 |     q = partition(A, n , p, r);
      |                   ^
main.c:84:15: error: type of formal parameter 1 is incomplete
   84 |     quickSort(A, n, p, q-1);
      |               ^
main.c:85:15: error: type of formal parameter 1 is incomplete
   85 |     quickSort(A, n, q+1, r);
      |               ^
main.c: In function 'main':
main.c:93:15: error: array type has incomplete element type 'struct Card'
   93 |   struct Card A[MAX], B[MAX];
      |               ^
main.c:93:23: error: array type has incomplete element type 'struct Card'
   93 |   struct Card A[MAX], B[MAX];
      |                       ^
main.c:97:3: error: implicit declaration of function 'scanf' [-Wimplicit-function-declaration]
   97 |   scanf("%d",&n);
      |   ^~~~~
main.c:1:1: note: include '<stdio.h>' or provide a declaration of 'scanf'
  +++ |+#include <stdio.h>
    1 | include<stdio.h>
main.c:97:3: warning: incompatible implicit declaration of built-in function 'scanf' [-Wbuiltin-declaration-mismatch]
   97 |   scanf("%d",&n);
      |   ^~~~~
main.c:97:3: note: include '<stdio.h>' or provide a declaration of 'scanf'
main.c:105:13: error: type of formal parameter 1 is incomplete
  105 |   mergeSort(A, n, 0, n);
      |             ^
main.c:106:13: error: type of formal parameter 1 is incomplete
  106 |   quickSort(B, n, 0, n-1);
      |             ^
main.c:115:5: error: implicit declaration of function 'printf' [-Wimplicit-function-declaration]
  115 |     printf("Stable\n");
      |     ^~~~~~
main.c:115:5: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:115:5: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
main.c:115:5: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:118:5: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
  118 |     printf("Not stable\n");
      |     ^~~~~~
main.c:118:5: note: include '<stdio.h>' or provide a declaration of 'printf'
main.c:122:5: warning: incompatible implicit declaration of built-in function 'printf' [-Wbuiltin-declaration-mismatch]
  122 |     printf("%c %d\n", B[i].suit, B[i].value);
      |     ^~~~~~
main.c:122:5: note: include '<stdio.h>' or provide a declaration of 'printf'