Language: C

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <stdint.h>
#include <float.h>
#include <limits.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <stdint.h>

#define _GNU_SOURCE
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-security"

#ifndef CS50_H
#define CS50_H

typedef unsigned char byte;
typedef char *string;
char get_char(const string format, ...) __attribute__((format(printf, 1, 2)));
double get_double(const string format, ...) __attribute__((format(printf, 1, 2)));
float get_float(const string format, ...) __attribute__((format(printf, 1, 2)));
int get_int(const string format, ...) __attribute__((format(printf, 1, 2)));
long get_long(const string format, ...) __attribute__((format(printf, 1, 2)));
string get_string(va_list *args, const string format, ...) __attribute__((format(printf, 2, 3)));
#define get_string(...) get_string(NULL, __VA_ARGS__)
#endif

bool pun_int(float P[], float Q[], float R[]);

int main(void)
{
  int m,i;
  scanf("%d",&m);
  string cadena1[m],*cadena2[m];
  get_string(cadena1);
  get_string(cadena2);
  for(i=0,i<m,i++)
        {
          prinft("%s",cadena1[i]);
          prinft("%s",cadena2[i]);
        }
  return 0;
}
        
bool pun_int(float P[], float Q[], float R[])
{
if((fabsf(P[0]-R[0])<=fabsf(P[0]-Q[0]))&&(fabsf(Q[0]-R[0])<=fabsf(P[0]-Q[0]))&&(fabsf(P[1]-R[1])<=fabsf(P[1]-Q[1]))&&(fabsf(Q[1]-R[1])<=fabsf(P[1]-Q[1])))
    {
        return true;
    }
    return false;
}

static size_t allocations = 0;
static string *strings = NULL;
#undef get_string
string get_string(va_list *args, const string format, ...)
{
    // Check whether we have room for another string
    if (allocations == SIZE_MAX / sizeof (string))
    {
        return NULL;
    }

    // Growable buffer for characters
    string buffer = NULL;

    // Capacity of buffer
    size_t capacity = 0;

    // Number of characters actually in buffer
    size_t size = 0;

    // Character read or EOF
    int c;

    // Prompt user
    if (format != NULL)
    {
        // Initialize variadic argument list
        va_list ap;
        if (args == NULL)
        {
            va_start(ap, format);
        }
        else
        {
            // Put a copy of argument list in ap so it is not consumed by vprintf
            va_copy(ap, *args);
        }

        // Print prompt
        vprintf(format, ap);

        // Clean up argument list
        va_end(ap);
    }

    // Iteratively get characters from standard input, checking for CR (Mac OS), LF (Linux), and CRLF (Windows)
    while ((c = fgetc(stdin)) != '\r' && c != '\n' && c != EOF)
    {
        // Grow buffer if necessary
        if (size + 1 > capacity)
        {
            // Increment buffer's capacity if possible
            if (capacity < SIZE_MAX)
            {
                capacity++;
            }
            else
            {
                free(buffer);
                return NULL;
            }

            // Extend buffer's capacity
            string temp = realloc(buffer, capacity);
            if (temp == NULL)
            {
                free(buffer);
                return NULL;
            }
            buffer = temp;
        }

        // Append current character to buffer
        buffer[size++] = c;
    }

    // Check whether user provided no input
    if (size == 0 && c == EOF)
    {
        return NULL;
    }

    // Check whether user provided too much input (leaving no room for trailing NUL)
    if (size == SIZE_MAX)
    {
        free(buffer);
        return NULL;
    }

    // If last character read was CR, try to read LF as well
    if (c == '\r' && (c = fgetc(stdin)) != '\n')
    {
        // Return NULL if character can't be pushed back onto standard input
        if (c != EOF && ungetc(c, stdin) == EOF)
        {
            free(buffer);
            return NULL;
        }
    }

    // Minimize buffer
    string s = realloc(buffer, size + 1);
    if (s == NULL)
    {
        free(buffer);
        return NULL;
    }

    // Terminate string
    s[size] = '\0';

    // Resize array so as to append string
    string *tmp = realloc(strings, sizeof (string) * (allocations + 1));
    if (tmp == NULL)
    {
        free(s);
        return NULL;
    }
    strings = tmp;

    // Append string to array
    strings[allocations] = s;
    allocations++;

    // Return string
    return s;
}

char get_char(const string format, ...)
{
    va_list ap;
    va_start(ap, format);

    // Try to get a char from user
    while (true)
    {
        // Get line of text, returning CHAR_MAX on failure
        string line = get_string(&ap, format);
        if (line == NULL)
        {
            va_end(ap);
            return CHAR_MAX;
        }

        // Return a char if only a char was provided
        char c, d;
        if (sscanf(line, "%c%c", &c, &d) == 1)
        {
            va_end(ap);
            return c;
        }
    }
}

double get_double(const string format, ...)
{
    va_list ap;
    va_start(ap, format);

    // Try to get a double from user
    while (true)
    {
        // Get line of text, returning DBL_MAX on failure
        string line = get_string(&ap, format);
        if (line == NULL)
        {
            va_end(ap);
            return DBL_MAX;
        }

        // Return a double if only a double was provided
        if (strlen(line) > 0 && !isspace((unsigned char) line[0]))
        {
            char *tail;
            errno = 0;
            double d = strtod(line, &tail);
            if (errno == 0 && *tail == '\0' && isfinite(d) != 0 && d < DBL_MAX)
            {
                // Disallow hexadecimal and exponents
                if (strcspn(line, "XxEePp") == strlen(line))
                {
                    va_end(ap);
                    return d;
                }
            }
        }
    }
}

float get_float(const string format, ...)
{
    va_list ap;
    va_start(ap, format);

    // Try to get a float from user
    while (true)
    {
        // Get line of text, returning FLT_MAX on failure
        string line = get_string(&ap, format);

        if (line == NULL)
        {
            va_end(ap);
            return FLT_MAX;
        }

        // Return a float if only a float was provided
        if (strlen(line) > 0 && !isspace((unsigned char) line[0]))
        {
            char *tail;
            errno = 0;
            float f = strtof(line, &tail);
            if (errno == 0 && *tail == '\0' && isfinite(f) != 0 && f < FLT_MAX)
            {
                // Disallow hexadecimal and exponents
                if (strcspn(line, "XxEePp") == strlen(line))
                {
                    va_end(ap);
                    return f;
                }
            }
        }
    }
}

int get_int(const string format, ...)
{
    va_list ap;
    va_start(ap, format);

    // Try to get an int from user
    while (true)
    {
        // Get line of text, returning INT_MAX on failure
        string line = get_string(&ap, format);
        if (line == NULL)
        {
            va_end(ap);
            return INT_MAX;
        }

        // Return an int if only an int (in range) was provided
        if (strlen(line) > 0 && !isspace((unsigned char) line[0]))
        {
            char *tail;
            errno = 0;
            long n = strtol(line, &tail, 10);
            if (errno == 0 && *tail == '\0' && n >= INT_MIN && n < INT_MAX)
            {
                va_end(ap);
                return n;
            }
        }
    }
}

long get_long(const string format, ...)
{
    va_list ap;
    va_start(ap, format);

    // Try to get a long from user
    while (true)
    {
        // Get line of text, returning LONG_MAX on failure
        string line = get_string(&ap, format);
        if (line == NULL)
        {
            va_end(ap);
            return LONG_MAX;
        }

        // Return a long if only a long (in range) was provided
        if (strlen(line) > 0 && !isspace((unsigned char) line[0]))
        {
            char *tail;
            errno = 0;
            long n = strtol(line, &tail, 10);
            if (errno == 0 && *tail == '\0' && n < LONG_MAX)
            {
                va_end(ap);
                return n;
            }
        }
    }
}

static void teardown(void)
{
    // Free library's strings
    if (strings != NULL)
    {
        size_t i;
        for (i = 0; i < allocations; i++)
        {
            free(strings[i]);
        }
        free(strings);
    }
}

#if defined (_MSC_VER) // MSVC
    #pragma section(".CRT$XCU",read)
    #define INITIALIZER_(FUNC,PREFIX) \
        static void FUNC(void); \
        __declspec(allocate(".CRT$XCU")) void (*FUNC##_)(void) = FUNC; \
        __pragma(comment(linker,"/include:" PREFIX #FUNC "_")) \
        static void FUNC(void)
    #ifdef _WIN64
        #define INITIALIZER(FUNC) INITIALIZER_(FUNC,"")
    #else
        #define INITIALIZER(FUNC) INITIALIZER_(FUNC,"_")
    #endif
#elif defined (__GNUC__) // GCC, Clang, MinGW
    #define INITIALIZER(FUNC) \
        static void FUNC(void) __attribute__((constructor)); \
        static void FUNC(void)
#else
    #error The CS50 library requires some compiler-specific features, \
           but we do not recognize this compiler/version. Please file an issue at \
           https://github.com/cs50/libcs50
#endif

/**
 * Called automatically before execution enters main.
 */
INITIALIZER(setup)
{
    // Disable buffering for standard output
    setvbuf(stdout, NULL, _IONBF, 0);
    atexit(teardown);
}

// Re-enable warnings
#pragma GCC diagnostic pop

Compiler output:
main.c: In function 'main':
main.c:42:14: error: passing argument 2 of 'get_string' from incompatible pointer type [-Wincompatible-pointer-types]
   42 |   get_string(cadena1);
      |              ^~~~~~~
      |              |
      |              char **
main.c:32:42: note: in definition of macro 'get_string'
   32 | #define get_string(...) get_string(NULL, __VA_ARGS__)
      |                                          ^~~~~~~~~~~
main.c:31:47: note: expected 'string' {aka 'char * const'} but argument is of type 'char **'
   31 | string get_string(va_list *args, const string format, ...) __attribute__((format(printf, 2, 3)));
      |                                  ~~~~~~~~~~~~~^~~~~~
main.c:43:14: error: passing argument 2 of 'get_string' from incompatible pointer type [-Wincompatible-pointer-types]
   43 |   get_string(cadena2);
      |              ^~~~~~~
      |              |
      |              char ***
main.c:32:42: note: in definition of macro 'get_string'
   32 | #define get_string(...) get_string(NULL, __VA_ARGS__)
      |                                          ^~~~~~~~~~~
main.c:31:47: note: expected 'string' {aka 'char * const'} but argument is of type 'char ***'
   31 | string get_string(va_list *args, const string format, ...) __attribute__((format(printf, 2, 3)));
      |                                  ~~~~~~~~~~~~~^~~~~~
main.c:44:18: error: expected ';' before ')' token
   44 |   for(i=0,i<m,i++)
      |                  ^
      |                  ;
main.c:44:18: error: expected expression before ')' token
main.c:46:11: error: implicit declaration of function 'prinft'; did you mean 'printf'? [-Wimplicit-function-declaration]
   46 |           prinft("%s",cadena1[i]);
      |           ^~~~~~
      |           printf