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

#define MAXVERTICES 2000

typedef int TVertice;

typedef int TAresta;

typedef struct {
  TVertice Vertice;
  TAresta Aresta;
} TAdjacencia;

typedef TAdjacencia TItem;

typedef struct SCelula *TApontador;

typedef struct SCelula {
  TItem Item;
  TApontador Prox;
} TCelula;

typedef struct {
  TApontador Primeiro, Ultimo;
  int Tamanho;
} TLista;

/* Inicia as variaveis da lista */
void TLista_Inicia(TLista *pLista)
{
  pLista->Primeiro = NULL;
  pLista->Ultimo = pLista->Primeiro;
  pLista->Tamanho = 0;
}

/* Retorna se a lista esta vazia */
int TLista_EhVazia(TLista *pLista)
{
  return (pLista->Primeiro == NULL);
}

/* Retorna o tamanho da lista */
int TLista_Tamanho(TLista *pLista)
{
  return (pLista->Tamanho);
}

/* Insere um item na primeira posicao da lista */
int TLista_InserePrimeiro(TLista *pLista, TItem x)
{
  TApontador pNovo;

  pNovo = (TApontador) malloc(sizeof(TCelula));
  pNovo->Item = x;
  pNovo->Prox = pLista->Primeiro;
  if (TLista_EhVazia(pLista))
    pLista->Ultimo = pNovo;
  pLista->Primeiro = pNovo;
  pLista->Tamanho++;
  return 1;
}

/* Insere um item na ultima posicao da lista */
int TLista_InsereUltimo(TLista *pLista, TItem x)
{
  TApontador pNovo;

  pNovo = (TApontador) malloc(sizeof(TCelula));
  pNovo->Item = x;
  pNovo->Prox = NULL;

  if (TLista_EhVazia(pLista))
    pLista->Primeiro = pNovo;
  else
    pLista->Ultimo->Prox = pNovo;
  pLista->Ultimo = pNovo;
  pLista->Tamanho++;
  return 1;
}

/* Insere um item na lista na posicao apontada por p */
int TLista_Insere(TLista *pLista, TApontador p, TItem x)
{
  TApontador pAnterior, pNovo;

  if (p == pLista->Primeiro)
    return TLista_InserePrimeiro(pLista, x);
  else if (p == NULL)
    return TLista_InsereUltimo(pLista, x);
  else {
    pAnterior = pLista->Primeiro;
    while ((pAnterior != pLista->Ultimo) && (pAnterior->Prox != p))
      pAnterior = pAnterior->Prox;
    if (pAnterior == pLista->Ultimo)
      return 0;

    pNovo = (TApontador) malloc(sizeof(TCelula));
    pNovo->Item = x;
    pNovo->Prox = pAnterior->Prox;
    pAnterior->Prox = pNovo;
    pLista->Tamanho++;
    return 1;
  }
}

/* Retira o item da primeira posicao da lista */
int TLista_RetiraPrimeiro(TLista *pLista, TItem *pX)
{
  TApontador pAux;

  if (TLista_EhVazia(pLista))
    return 0;

  pAux = pLista->Primeiro;
  pLista->Primeiro = pAux->Prox;
  *pX = pAux->Item;
  free(pAux);
  pLista->Tamanho--;

  return 1;
}

/* Retira o item da ultima posicao da lista */
int TLista_RetiraUltimo(TLista *pLista, TItem *pX)
{
  TApontador pAnterior, pAux;

  pAnterior = pLista->Primeiro;
  if (pAnterior == pLista->Ultimo)
    return TLista_RetiraPrimeiro(pLista, pX);
  else {
    while (pAnterior->Prox != pLista->Ultimo)
      pAnterior = pAnterior->Prox;

    pAux = pLista->Ultimo;
    pAnterior->Prox = NULL;
    pLista->Ultimo = pAnterior;
    *pX = pAux->Item;
    free(pAux);
    pLista->Tamanho--;

    return 1;
  }
}

/* Retira o item da lista da posicao apontada por p */
int TLista_Retira(TLista *pLista, TApontador p, TItem *pX)
{
  TApontador pAnterior, pAux;

  if (p == pLista->Primeiro)
    return TLista_RetiraPrimeiro(pLista, pX);
  else if (p == pLista->Ultimo)
    return TLista_RetiraUltimo(pLista, pX);
  else {
    pAnterior = pLista->Primeiro;
    while ((pAnterior != pLista->Ultimo) && (pAnterior->Prox != p))
      pAnterior = pAnterior->Prox;
    if (pAnterior == pLista->Ultimo)
      return 0;

    pAux = pAnterior->Prox;
    pAnterior->Prox = pAux->Prox;
    *pX = pAux->Item;
    free(pAux);
    pLista->Tamanho--;
    return 1;
  }
}

/* Retorna um apontador para o p-esimo item da lista */
TApontador TLista_Retorna(TLista *pLista, int p)
{
  TApontador q;
  int pos;

  pos = 0;
  q = pLista->Primeiro;
  while ((q != NULL) && (pos != p)) {
    q = q->Prox;
    pos++;
  }

  return q;
}

typedef struct {
  TLista Adj[MAXVERTICES];
  int NVertices;
  int NArestas;
} TGrafo;

/* Inicia as variaveis do grafo */
int TGrafo_Inicia(TGrafo *pGrafo, int NVertices)
{
  TVertice u;

  if (NVertices > MAXVERTICES)
    return 0;

  pGrafo->NVertices = NVertices;
  pGrafo->NArestas  = 0;
  for (u = 0; u < pGrafo->NVertices; u++)
    TLista_Inicia(&pGrafo->Adj[u]);

  return 1;
}

/* Retorna o numero de vertices do grafo */
int TGrafo_NVertices(TGrafo *pGrafo)
{
  return (pGrafo->NVertices);
}

/* Retorna o numero de arestas do grafo */
int TGrafo_NArestas(TGrafo *pGrafo)
{
  return (pGrafo->NArestas);
}

/* Retorna se existe a aresta (u, v) no grafo */
int TGrafo_ExisteAresta(TGrafo *pGrafo, TVertice u, TVertice v)
{
  TAdjacencia Adj;
  TLista ListaAdj;
  int IncideAresta;

  IncideAresta = 0;
  TLista_Inicia(&ListaAdj);
  while (TLista_RetiraPrimeiro(&pGrafo->Adj[u], &Adj)) {
    TLista_InsereUltimo(&ListaAdj, Adj);
    IncideAresta = (Adj.Vertice == v);
    if (IncideAresta)
      break;
  }

  while (TLista_RetiraPrimeiro(&ListaAdj, &Adj))
    TLista_InsereUltimo(&pGrafo->Adj[u], Adj);

  return (IncideAresta);
}

/* Insere a aresta e incidente aos vertices u e v no grafo */
int TGrafo_InsereAresta(TGrafo *pGrafo, TVertice u, TVertice v, TAresta e)
{
  TAdjacencia Adj;

  Adj.Vertice = v;
  Adj.Aresta  = e;
  if (TLista_InsereUltimo(&pGrafo->Adj[u], Adj)) {
    pGrafo->NArestas++;
    return 1;
  }
  else
    return 0;
}

/* Retira a aresta e incidente aos vertices u e v no grafo */
int TGrafo_RetiraAresta(TGrafo *pGrafo, TVertice u, TVertice v, TAresta *pE)
{
  TLista ListaAdj;
  TAdjacencia Adj;
  int IncideAresta;

  IncideAresta = 0;
  TLista_Inicia(&ListaAdj);
  while (!IncideAresta && TLista_RetiraPrimeiro(&pGrafo->Adj[u], &Adj))
    if (Adj.Vertice == v) {
      *pE = Adj.Aresta;
      pGrafo->NArestas--;
      IncideAresta = 1;
    }
    else
      TLista_InsereUltimo(&ListaAdj, Adj);

  while (TLista_RetiraPrimeiro(&ListaAdj, &Adj))
    TLista_InsereUltimo(&pGrafo->Adj[u], Adj);

  return IncideAresta;
}

/* Retorna a lista de adjacentes do vertice u no grafo */
TLista *TGrafo_ListaAdj(TGrafo *pGrafo, TVertice u)
{
  TLista *pLista, ListaAdj;
  TAdjacencia Adj;

  pLista = (TLista *) malloc(sizeof(TLista));
  TLista_Inicia(pLista);

  TLista_Inicia(&ListaAdj);
  while (TLista_RetiraPrimeiro(&pGrafo->Adj[u], &Adj))
    TLista_InsereUltimo(&ListaAdj, Adj);

  while (TLista_RetiraPrimeiro(&ListaAdj, &Adj)) {
    TLista_InsereUltimo(&pGrafo->Adj[u], Adj);
    TLista_InsereUltimo(pLista, Adj);
  }

  return pLista;
}

#define NIL -1
#define INF -1

typedef int TTempo;

typedef struct {
  TVertice Pai;
  TTempo   Ini;
  TTempo   Fim;
} TBPInfo;

/* Realiza uma busca em profundidade no grafo a partir de um vertice */
void TGrafo_BPVRecursivo(TGrafo *pGrafo, TVertice u, TBPInfo *Info, TTempo *Tempo)
{
  TLista *ListaAdj;
  TAdjacencia Adj;
  TVertice v;

  Info[u].Ini = ++(*Tempo);
  ListaAdj = TGrafo_ListaAdj(pGrafo, u);
  while (TLista_RetiraPrimeiro(ListaAdj, &Adj)) {
    v = Adj.Vertice;
    if (Info[v].Ini == 0) {
      Info[v].Pai = u;
      TGrafo_BPVRecursivo(pGrafo, v, Info, Tempo);
    }
  }
  free(ListaAdj);
  Info[u].Fim = ++(*Tempo);
}

/* Realiza uma busca em profundidade no grafo a partir de um vertice */
TBPInfo *TGrafo_BuscaProfundidadeNoVertice(TGrafo *pGrafo, TVertice s)
{
  TBPInfo *Info;
  TTempo Tempo;
  TVertice u;

  Info = (TBPInfo *) malloc(TGrafo_NVertices(pGrafo) * sizeof(TBPInfo));
  for (u = 0; u < TGrafo_NVertices(pGrafo); u++) {
    Info[u].Pai = NIL;
    Info[u].Ini = 0;
    Info[u].Fim = INF;
  }

  Tempo = 0;
  TGrafo_BPVRecursivo(pGrafo, s, Info, &Tempo);

  return Info;
}

/* Realiza uma busca em profundidade no grafo */
TBPInfo *TGrafo_BuscaProfundidade(TGrafo *pGrafo)
{
  TBPInfo *Info;
  TTempo Tempo;
  TVertice u;

  Info = (TBPInfo *) malloc(TGrafo_NVertices(pGrafo) * sizeof(TBPInfo));
  for (u = 0; u < TGrafo_NVertices(pGrafo); u++) {
    Info[u].Pai = NIL;
    Info[u].Ini = 0;
    Info[u].Fim = INF;
  }

  Tempo = 0;
  for (u = 0; u < TGrafo_NVertices(pGrafo); u++)
    if (Info[u].Ini == 0)
      TGrafo_BPVRecursivo(pGrafo, u, Info, &Tempo);

  return Info;
}

int main()
{
  TGrafo *pGrafo;
  int i, p, N, M;
  TVertice u, v;
  TBPInfo *Info;
  int EhConexo;

  scanf("%d %d", &N, &M);

  pGrafo = (TGrafo *) malloc(sizeof(TGrafo));
  TGrafo_Inicia(pGrafo, N);

  for (i = 0; i < M; i++) {
    scanf("%d %d %d", &u, &v, &p);
    TGrafo_InsereAresta(pGrafo, u-1, v-1, 0);
    if (p == 2)
        TGrafo_InsereAresta(pGrafo, v-1, u-1, 0);
  }

  EhConexo = 1;
  for (u = 0; u < N && EhConexo; u++) {
    Info = TGrafo_BuscaProfundidadeNoVertice(pGrafo, u);
    for (v = 0; v < N && EhConexo; v++)
      if ((u != v) && (Info[v].Pai == NIL))
        EhConexo = 0;
    free(Info);
  }
  printf("%d\n", EhConexo);

  return 1;
}