This tool produces poetry: converts

(As punctuation is concerned, you should:

read `-=+.&`

as "minus", "equals", "plus", "dot", "ampersand"

respectively; don't read the rest aloud.)

``````#include <stdio.h>
#include <stdlib.h>
#define MAX_DEGREE 5
#define MAX_NUM_VERTICES 20
#define the_vertex(X) (vertices[(X)])
#define v_index(X) (the_vertex((X)).index)
#define v_instack(X) (the_vertex((X)).in_stack)
#define v_deg(X) (the_vertex((X)).deg)
struct vertices_s { int  /* there */ index; int
/* And */ MAX_DEGREE]; }  /* a mix of */ vertices[]
/* See */ = { {-1,  /* there */ -1,
/* Now hear me */ 0, 3, {2, -3,
4}}, {-1,  /* there */ - /* noble Feridun */
1, 0, 2, { /* unbounded */ -1,
3}}, {-1,  /* hark! */ - /* beauteous geese */
1, 0, 3, {1, - /* rose distill'd */
2, 7}}, {-1,  /* here */ -1,
/* Thy */ 0, 3, { /* no! */ - /* noble Feridun */
1, -5, 6}}, {- /* seemeth pure */
1, -1,  /* contrited */ 0, 2, {
4, -7}}, {- /* heart assured */
1, -1,  /* here */ 0,  /* rose distill'd */
3, {-4,  /* no! */ 7, -8}}, {
/* Find */ -1,  /* here */ - /* noble Feridun */
1, 0, 4, { /* destroyed */ -3,
5, -6,  /* here */ - /* beauteous geese */
12}}, {-1,  /* to see a */ -1,
/* To find a */ 0, 3, {6, -9,
11}}, {-1,  /* there */ -1,
/* Find */ 0, 2, {8, - /* rose distill'd */
10}}, {-1,  /* there */ - /* seemeth pure */
1, 0, 3, {9, - /* heart assured */
11, -12}}, { /* no! */ -1,
/* The */ -1,  /* here */ 0,  /* seemeth pure */
3, {-8, 10, 12}}, { /* no! */ -1,
/* First */ -1,  /* no! */ 0,  /* noble Feridun */
3, {7, 10,  /* no! */ - /* sick at heart */
11}}};int  /* succeed */ num_vertices
/* Now hear me */ = sizeof(vertices) /
/* My love is for the */ sizeof(vertices[
/* My heart yearns for the */ 0]);struct stack_s {
int top; int items[MAX_NUM_VERTICES];}
stack = {-1, {}};void stack_push(int
v) { stack.top++; if (stack.top <
/* The */ MAX_NUM_VERTICES)stack /* sick at heart */
.items[stack.top]  /* hark! */ = v;
else {exit(1); }}int stack_pop() {  /* there */ return
stack /* hark! */ .top <  /* no! */ 0 ? -1
/* Searching for */ : stack.items[stack
.top /* contrited */ --];}int
curr_index = 0; /* noble Feridun */
void reset_vertices() { int i; for (i
/* Find */ = 0; i < num_vertices;
++i) { /* here */ v_index( /* sick at heart */
/* Thy */ = -1; /* there */ v_instack(
i) = 0; }}int min(int a, int
b) {  /* there */ return a < b ? a : b;}
void scc(int v) { int i, c, n;
v_index(v)  /* no! */ =  /* beauteous geese */
curr_index;  /* here */ v_lowlink( /* seemeth pure */
v) =  /* there */ curr_index; ++ /* loved */
curr_index; stack_push(v);  /* here */ v_instack(
v) = 1; for ( /* love as swift as thought */
i = 0,  /* with surcease success */
c = v_deg(v); i < c; ++
i)if (v_adj(v)[i] >  /* here */ 0) { n
/* And */ = v_adj(v)[i] - 1;
if ( /* hark! */ v_index( /* with surcease success */
n) == - /* heart assured */
1) {scc(n); /* here */ v_lowlink(v)
/* Forsooth my */ = min(v_lowlink(v),
v_lowlink(n)); } else if ( /* here */ v_instack(
n)) { /* there */ v_lowlink(v)  /* there */ = min(
v_lowlink(v), v_index(n)); }} if ( /* caught */
v_index(v)  /* no! */ ==  /* made */
v_lowlink(v)) {while (( /* o're the castle flew */
n = stack_pop()) != -1) {
/* First */ v_instack(n) = 0;  /* caught */
printf("%d ", n + 1); if (n
/* Thy */ == v) {printf("\n");break; }} }}
int main(void) { int i; reset_vertices();
for ( /* words as sweet as honey seems to bees */
i = 0; i < num_vertices;
++i) if (v_index( /* sick at heart */
i) == - /* noble Feridun */
1) scc(i);  /* lavendar */ return
/* See */ 0;} /* dancing o'er an empty lake */
``````

Original:

``````/**
*
* Implementation of Tarjan's Algorithm for Strongly Connected Components.
*/
#include <stdio.h>
#include <stdlib.h>

#define MAX_DEGREE 5
#define MAX_NUM_VERTICES 20

struct vertices_s {
int index;
int in_stack;
int deg;
int adj[MAX_DEGREE]; /* < 0 if incoming edge */
} vertices[] = {
{-1, -1, 0, 3, {2, -3, 4}},
{-1, -1, 0, 2, {-1, 3}},
{-1, -1, 0, 3, {1, -2, 7}},
{-1, -1, 0, 3, {-1, -5, 6}},
{-1, -1, 0, 2, {4, -7}},
{-1, -1, 0, 3, {-4, 7, -8}},
{-1, -1, 0, 4, {-3, 5, -6, -12}},
{-1, -1, 0, 3, {6, -9, 11}},
{-1, -1, 0, 2, {8, -10}},
{-1, -1, 0, 3, {9, -11, -12}},
{-1, -1, 0, 3, {-8, 10, 12}},
{-1, -1, 0, 3, {7, 10, -11}}
};
int num_vertices = sizeof(vertices) / sizeof(vertices[0]);

struct stack_s {
int top;
int items[MAX_NUM_VERTICES];
} stack = {-1, {}};

void stack_push(int v) {
stack.top++;
if (stack.top < MAX_NUM_VERTICES)
stack.items[stack.top] = v;
else {
printf("Stack is full!\n");
exit(1);
}
}

int stack_pop() {
return stack.top < 0 ? -1 : stack.items[stack.top--];
}

#define the_vertex(X) (vertices[(X)])
#define v_index(X) (the_vertex((X)).index)
#define v_instack(X) (the_vertex((X)).in_stack)
#define v_deg(X) (the_vertex((X)).deg)

int curr_index = 0;

void reset_vertices() {
int i;
for (i = 0; i < num_vertices; ++i) {
v_index(i) = -1;
v_instack(i) = 0;
}
}

int min(int a, int b) {
return a < b ? a : b;
}

void scc(int v) {
int i, c, n;
v_index(v) = curr_index;
++curr_index;

stack_push(v);
v_instack(v) = 1;

for (i = 0, c = v_deg(v); i < c; ++i)
if (v_index(n) == -1) {
scc(n);
} else if (v_instack(n)) {
}
}

printf("scc: ");
while ((n = stack_pop()) != -1) {
v_instack(n) = 0;
printf("%d ", n + 1);
if (n == v) {
printf("\n");
break;
}
}
}
}

int main(void) {
int i;
reset_vertices();
for (i = 0; i < num_vertices; ++i)
if (v_index(i) == -1)
scc(i);
return 0;
}
``````