#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define NMAX 50005
 
struct Node {
    int data;
    struct Node *next;
};
 
typedef struct {
    struct Node *head;
    struct Node *tail;
    int size;
} LinkedList;
 
typedef struct {
    LinkedList **neighbors;
    int nodes;
} ListGraph;
 
void add_edge_list_graph(ListGraph *graph, int src, int dest) {
	struct Node *p;
	for (p = graph->neighbors[src]->head; p; p = p->next) {
		if (p->data == dest) {
			return;
		}
	}
    add_nth_node(graph->neighbors[src], (1 <<30), dest);
}

void dfs_topo_sort(ListGraph *lg, int *node, int *visited, LinkedList *result) {
    int x = *node;
    if(visited[x]) return;
    visited[x] = 1;
    for(Node* it = lg->neighbors[x]->head; it; it = it->next){
        dfs_topo_sort(lg, it->data, visited, result);
    }
    add_nth_node(result, 0, node);
}

void topo_sort(ListGraph *lg, FILE *out) {
    int visited[NMAX], ind[NMAX];
    int numb = 0;
    memset(visited,0,NMAX);
    for (int j= 1; j < lg->nodes; j++) {
    	if (visited[j] == 0) {
    		dfs_topo_sort(lg, i, visited, ind, &n);
    	}
    for (i = numb - 1; i >= 0; i--) {
    	fprintf(out, "%d ", ind[i]);
    }
}
 
 void init_list(LinkedList *list) {
    list->head = NULL;
    list->tail = NULL;
    list->size = 0;
}
 
void init_list_graph(ListGraph *graph, int nodes) {
    graph->nodes = nodes;
    graph->neighbors = malloc(nodes * sizeof(LinkedList));
 
    if (graph->neighbors == NULL) {
        perror("Not enough memory to initialize the adjacency list!");
        exit(-1);
    }
 
    for (int i = 0; i < nodes; ++i) {
        graph->neighbors[i] = malloc(sizeof(LinkedList));
 
        if (graph->neighbors[i] == NULL) {
            perror("Not enough memory to initialize the adjacency list!");
            exit(-1);
        }
        init_list(graph->neighbors[i]);
    }
}
 
void add_nth_node(LinkedList *list, int n, int new_data) {
    struct Node *prev, *curr;
    struct Node *new_node;
 
    if (list == NULL) {
        return;
    }
 
    if (n > list->size) {
        n = list->size;
    } else if (n < 0) {
        return;
    }
 
    curr = list->head;
    prev = NULL;
    while (n > 0) {
        prev = curr;
        curr = curr->next;
        --n;
    }
 
    new_node = malloc(sizeof(struct Node));
    if (new_node == NULL) {
        perror("Not enough memory to add element!");
        exit(-1);
    }
    
    new_node->data = new_data;
    new_node->next = curr;
    if (prev == NULL) {
        list->head = new_node;
    } else {
        prev->next = new_node;
    }
 
    if (new_node->next == NULL) {
        list->tail = new_node;
    }
 
    list->size++;
}
 

void print_int_linkedlist(LinkedList *list) {
    struct Node *curr;
 
    if (list == NULL) {
        return;
    }
 
    curr = list->head;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
 
    printf("\n");
}
 
void print_list_graph(ListGraph *g) {
    int i;
    for (i = 1; i <= g->nodes; i++) {
        printf("%d: ", i);
        print_int_linkedlist(g->neighbors[i]);
    }
}
 
int main() {
	FILE *in = fopen("sortaret.in", "rt"); *out = fopen("sortaret.out", "wt");
	int n, m, i, x, y;
	ListGraph *lg = malloc(sizeof(ListGraph));
	fscanf(in, "%d %d", &n, &m);
	init_list_graph(lg, n + 1);
 
	for (i = 0; i < m; ++i) {
        fscanf(in, "%d %d", &x, &y);
        add_edge_list_graph(lg, x, y);
    }
    topo_sort(lg, out);
    fprintf(out, "\n");
 
    fclose(in);
    fclose(out);
}