Comparing two recursive ways to test linked list equivalence

compare.c

#include "compare.h"

bool compare_lists(Node* a, Node* b) {
    if(!a && !b)
        return true;
    else if((bool)a ^ (bool)b)
        return false;
    else
        return a->data == b->data
            && compare_lists(a->next, b->next);
}

compare.h

#pragma once

#include <stdbool.h>
#include "node.h"

bool compare_lists(Node* a, Node* b);

compare_tail.c

#include "compare.h"

bool _compare_lists(Node* a, Node* b, bool eq);


bool compare_lists(Node* a, Node* b) {
    return _compare_lists(a, b, true);
}


bool _compare_lists(Node* a, Node* b, bool eq) {
    if(!eq)
        return false;
    else if(!a && !b)
        return true;
    else if((bool)a ^ (bool)b)
        return false;
    else
        return _compare_lists(
                a->next, b->next,
                eq && a->data == b->data);
}

main.c

#include <stdbool.h>
#include <stdio.h>
#include "compare.h"
#include "node.h"

int main(void) {
    int n, m;
    scanf("%d %d", &n, &m);

    Node* a = read_list(n)
      , * b = read_list(m);

    bool eq = compare_lists(a, b);
    printf("%d\n", eq);

    return 0;
}

Makefile

N=1000000
M=1000000
M2=1000001

compare: node.o compare.o main.o
	$(CC) $^ -o $@

compare_tail: node.o compare_tail.o main.o
	$(CC) $^ -o $@

%.o: %.c
	$(CC) -c $< -o $@

input0:
	echo "$(N) $(N)" > $@
	shuf -i 1-$(N) > $@.tmp1
	shuf -i 1-$(N) > $@.tmp2
	cat $@.tmp1 >> $@
	cat $@.tmp2 >> $@
	rm $@.tmp{1,2}

input1:
	echo "$(N) $(N)" > $@
	shuf -i 1-$(N) > $@.tmp
	cat $@.tmp >> $@
	cat $@.tmp >> $@
	rm $@.tmp

input2:
	echo "$(N) $(M2)" > $@
	shuf -i 1-$(N) > $@.tmp
	cat $@.tmp >> $@
	shuf -i 1-$(M2) > $@.tmp
	cat $@.tmp >> $@
	rm $@.tmp


benchmark: compare compare_tail input0 input1 input2
	time ./compare < input0
	time ./compare < input1
	time ./compare < input2
	time ./compare_tail < input0
	time ./compare_tail < input1
	time ./compare_tail < input2

.PHONY:
clean:
	rm -f *.{o,s,out} input* compare compare_tail

node.c

#include <stdio.h>
#include <stdlib.h>
#include "node.h"

Node* read_list(int len) {
    if(len <= 0)
        return NULL;

    Node* head = malloc(sizeof(Node))
      , * curr = head;

    for(int i = 0; i < len; i++) {
        scanf("%d", &curr->data);
        if(i < len - 1) {
            curr->next = malloc(sizeof(Node));
            curr = curr->next;
        } else
            curr->next = NULL;
    }

    return head;
}

node.h

#pragma once

typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* read_list(int len);