/*#################################################################

PROJECTO: EMULADOR DO GLiTCH

   Grupo de Engenharia de Computadores
	Departamento de Informática
   Universidade do Minho
   Braga - PORTUGAL

   Ficheiro: pblwrite.c
   Linguagem: C
   Chip: Transputer
   Data de Inicio: 15/Abr/1992
   Data de Finalização: 29/Abr/1992
   Autor: João Miguel Lobo Fernandes

   Alteração: António J. A. Esteves
   Data Alteração: 16/Mar/1996

   Nota:
     - Além das funções do PBL, são feitas as da CAM

##################################################################*/
#include "datadef.h"
int parte1_pbl_write(void);
void parte2_pbl_write(void);

/*################################################################*/
/*# Esta funcao escreve determinados padroes na CAM e no subset   */
/*################################################################*/
void pbl_write (void)
{
if(parte1_pbl_write() == 1)
    parte2_pbl_write();
}

/*################################################################*/
/*  Esta funcao implementa a 2.a parte dos cases da funcao        */
/*  pbl_write()                                                   */
/*################################################################*/

void parte2_pbl_write (void)
{
  int i;
  char c1, c2;

/*
iniciar pos1, patt1, pos2, patt2 e subset (5 param)
ZERO=01, UM=10, DCARE=11

+-------------------------------------+
| PE_SEL_1    PE_SEL_2    DATA_SELECT |
|   0 all       0 all       0 global  |
|   1 subset    1 tag       1 tag     |
|   2 notsub    2 carry     2 carry   |
|               3 nottag              |
|               4 notcy               |
+-------------------------------------+
*/
  switch (linhas)
  {
/*****************************************************************/
	 case 102: /* subset all carry */
		for (i=0; i<8; i++)  /* O 1.o padrao tem 8 trits */
		{
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]=(cam[c1][0]&~ms[0]) | (~cy[0]&ms[0]);
            cam[c1][1]=(cam[c1][1]&~ms[1]) | (~cy[1]&ms[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&~ms[0]) | (cy[0]&ms[0]);
            cam[c1][1]=(cam[c1][1]&~ms[1]) | (cy[1]&ms[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 102 (1o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)     /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=(sub[i][0]&~ms[0]) | (~cy[0]&ms[0]);
            sub[i][1]=(sub[i][1]&~ms[1]) | (~cy[1]&ms[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&~ms[0]) | (cy[0]&ms[0]);
            sub[i][1]=(sub[i][1]&~ms[1]) | (cy[1]&ms[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 102 (padrao subset). \n");
            break;
        }
      }
      break;
/*****************************************************************/
	 case 110: /* subset tag global */
		for (i=0; i<8; i++)           /* Os 2 padroes tem 8 trits */
		{
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=(~ms[0]|~tag[0]);
            cam[c1][1]&=(~ms[1]|~tag[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(~ms[0]|~tag[0])) | (ms[0]&tag[0]);
            cam[c1][1]=(cam[c1][1]&(~ms[1]|~tag[1])) | (ms[1]&tag[1]);
          case DCARE:
            break;
          default:
				erro ("\nErro na funcao pbl_write() // caso 110 (1§ padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=(~ms[0]|~tag[0]);
            cam[c2][1]&=(~ms[1]|~tag[1]);
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&(~ms[0]|~tag[0])) | (ms[0]&tag[0]);
            cam[c2][1]=(cam[c2][1]&(~ms[1]|~tag[1])) | (ms[1]&tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 110 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)    /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=(~ms[0]|~tag[0]);
            sub[i][1]&=(~ms[1]|~tag[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(~ms[0]|~tag[0])) | (ms[0]&tag[0]);
            sub[i][1]=(sub[i][1]&(~ms[1]|~tag[1])) | (ms[1]&tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 110 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 112: /* subset tag carry */
      for (i=0; i<8; i++)         /* O 1.o padrao tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]=(cam[c1][0]&(~ms[0]|~tag[0])) | (ms[0]&tag[0]&~cy[0]);
            cam[c1][1]=(cam[c1][1]&(~ms[1]|~tag[1])) | (ms[1]&tag[1]&~cy[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(~ms[0]|~tag[0])) | (ms[0]&tag[0]&cy[0]);
            cam[c1][1]=(cam[c1][1]&(~ms[1]|~tag[1])) | (ms[1]&tag[1]&cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 112 (1o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)    /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=(sub[i][0]&(~ms[0]|~tag[0])) | (ms[0]&tag[0]&~cy[0]);
            sub[i][1]=(sub[i][1]&(~ms[1]|~tag[1])) | (ms[1]&tag[1]&~cy[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(~ms[0]|~tag[0])) | (ms[0]&tag[0]&cy[0]);
            sub[i][1]=(sub[i][1]&(~ms[1]|~tag[1])) | (ms[1]&tag[1]&cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 112 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 120: /* subset carry global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=(~ms[0]|~cy[0]);
            cam[c1][1]&=(~ms[1]|~cy[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(~ms[0]|~cy[0])) | (ms[0]&cy[0]);
            cam[c1][1]=(cam[c1][1]&(~ms[1]|~cy[1])) | (ms[1]&cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 120 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=(~ms[0]|~cy[0]);
            cam[c2][1]&=(~ms[1]|~cy[1]);
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&(~ms[0]|~cy[0])) | (ms[0]&cy[0]);
            cam[c2][1]=(cam[c2][1]&(~ms[1]|~cy[1])) | (ms[1]&cy[1]);

          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 120 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)      /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=(~ms[0]|~cy[0]);
            sub[i][1]&=(~ms[1]|~cy[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(~ms[0]|~cy[0])) | (ms[0]&cy[0]);
            sub[i][1]=(sub[i][1]&(~ms[1]|~cy[1])) | (ms[1]&cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 120 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 121: /* subset carry tag*/
      for (i=0; i<8; i++)         /* O 1.o padrao tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]=(cam[c1][0]&(~ms[0]|~cy[0])) | (ms[0]&cy[0]&~tag[0]);
            cam[c1][1]=(cam[c1][1]&(~ms[1]|~cy[1])) | (ms[1]&cy[1]&~tag[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(~ms[0]|~cy[0])) | (ms[0]&cy[0]&tag[0]);
            cam[c1][1]=(cam[c1][1]&(~ms[1]|~cy[1])) | (ms[1]&cy[1]&tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 121 (1o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)    /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=(sub[i][0]&(~ms[0]|~cy[0])) | (ms[0]&cy[0]&~tag[0]);
            sub[i][1]=(sub[i][1]&(~ms[1]|~cy[1])) | (ms[1]&cy[1]&~tag[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(~ms[0]|~cy[0])) | (ms[0]&cy[0]&tag[0]);
            sub[i][1]=(sub[i][1]&(~ms[1]|~cy[1])) | (ms[1]&cy[1]&tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 121 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 130: /* subset nottag global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=(~ms[0]|tag[0]);
            cam[c1][1]&=(~ms[1]|tag[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(~ms[0]|tag[0])) | (ms[0]&~tag[0]);
            cam[c1][1]=(cam[c1][1]&(~ms[1]|tag[1])) | (ms[1]&~tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 130 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=(~ms[0]|tag[0]);
            cam[c2][1]&=(~ms[1]|tag[1]);
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&(~ms[0]|tag[0])) | (ms[0]&~tag[0]);
            cam[c2][1]=(cam[c2][1]&(~ms[1]|tag[1])) | (ms[1]&~tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 130 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)     /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=(~ms[0]|tag[0]);
            sub[i][1]&=(~ms[1]|tag[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(~ms[0]|tag[0])) | (ms[0]&~tag[0]);
            sub[i][1]=(sub[i][1]&(~ms[1]|tag[1])) | (ms[1]&~tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 130 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 140: /* subset notcy global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=(~ms[0]|cy[0]);
            cam[c1][1]&=(~ms[1]|cy[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(~ms[0]|cy[0])) | (ms[0]&~cy[0]);
            cam[c1][1]=(cam[c1][1]&(~ms[1]|cy[1])) | (ms[1]&~cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 140 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=(~ms[0]|cy[0]);
            cam[c2][1]&=(~ms[1]|cy[1]);
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&(~ms[0]|cy[0])) | (ms[0]&~cy[0]);
            cam[c2][1]=(cam[c2][1]&(~ms[1]|cy[1])) | (ms[1]&~cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 140 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)     /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=(~ms[0]|cy[0]);
            sub[i][1]&=(~ms[1]|cy[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(~ms[0]|cy[0])) | (ms[0]&~cy[0]);
            sub[i][1]=(sub[i][1]&(~ms[1]|cy[1])) | (ms[1]&~cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 140 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 200: /* notsub all global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=ms[0];
            cam[c1][1]&=ms[1];
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&ms[0]) | ~ms[0];
            cam[c1][1]=(cam[c1][1]&ms[1]) | ~ms[1];
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 200 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=ms[0];
            cam[c2][1]&=ms[1];
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&ms[0]) | ~ms[0];
            cam[c2][1]=(cam[c2][1]&ms[1]) | ~ms[1];
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 200 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)     /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=ms[0];
            sub[i][1]&=ms[1];
            break;
          case UM:
            sub[i][0]=(sub[i][0]&ms[0]) | ~ms[0];
            sub[i][1]=(sub[i][1]&ms[1]) | ~ms[1];
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 200 (padrao subset). \n");
            break;
        }
      }

      break;
/******************************************************************/
    case 201: /* notsub all tag */
      for (i=0; i<8; i++)         /* O 1.o padrao tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]=(cam[c1][0]&ms[0]) | (~tag[0]&~ms[0]);
            cam[c1][1]=(cam[c1][1]&ms[1]) | (~tag[1]&~ms[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&ms[0]) | (tag[0]&~ms[0]);
            cam[c1][1]=(cam[c1][1]&ms[1]) | (tag[1]&~ms[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 201 (1o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)   /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=(sub[i][0]&ms[0]) | (~tag[0]&~ms[0]);
            sub[i][1]=(sub[i][1]&ms[1]) | (~tag[1]&~ms[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&ms[0]) | (tag[0]&~ms[0]);
            sub[i][1]=(sub[i][1]&ms[1]) | (tag[1]&~ms[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 201 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 202: /* notsub all carry */
      for (i=0; i<8; i++)         /* O 1.o padrao tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]=(cam[c1][0]&ms[0]) | (~cy[0]&~ms[0]);
            cam[c1][1]=(cam[c1][1]&ms[1]) | (~cy[1]&~ms[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&ms[0]) | (cy[0]&~ms[0]);
            cam[c1][1]=(cam[c1][1]&ms[1]) | (cy[1]&~ms[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 202 (1o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++) /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]=(sub[i][0]&ms[0]) | (~cy[0]&~ms[0]);
            sub[i][1]=(sub[i][1]&ms[1]) | (~cy[1]&~ms[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&ms[0]) | (cy[0]&~ms[0]);
            sub[i][1]=(sub[i][1]&ms[1]) | (cy[1]&~ms[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 202 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 210: /* notsub tag global */
      for (i=0; i<8; i++)           /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=(ms[0]|~tag[0]);
            cam[c1][1]&=(ms[1]|~tag[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(ms[0]|~tag[0])) | (~ms[0]&tag[0]);
            cam[c1][1]=(cam[c1][1]&(ms[1]|~tag[1])) | (~ms[1]&tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 210 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=(ms[0]|~tag[0]);
            cam[c2][1]&=(ms[1]|~tag[1]);
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&(ms[0]|~tag[0])) | (~ms[0]&tag[0]);
            cam[c2][1]=(cam[c2][1]&(ms[1]|~tag[1])) | (~ms[1]&tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 210 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)    /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=(ms[0]|~tag[0]);
            sub[i][1]&=(ms[1]|~tag[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(ms[0]|~tag[0])) | (~ms[0]&tag[0]);
            sub[i][1]=(sub[i][1]&(ms[1]|~tag[1])) | (~ms[1]&tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 210 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 220: /* notsub carry global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=(ms[0]|~cy[0]);
            cam[c1][1]&=(ms[1]|~cy[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(ms[0]|~cy[0])) | (~ms[0]&cy[0]);
            cam[c1][1]=(cam[c1][1]&(ms[1]|~cy[1])) | (~ms[1]&cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 220 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=(ms[0]|~cy[0]);
            cam[c2][1]&=(ms[1]|~cy[1]);
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&(ms[0]|~cy[0])) | (~ms[0]&cy[0]);
            cam[c2][1]=(cam[c2][1]&(ms[1]|~cy[1])) | (~ms[1]&cy[1]);

          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 220 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)     /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=(ms[0]|~cy[0]);
            sub[i][1]&=(ms[1]|~cy[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(ms[0]|~cy[0])) | (~ms[0]&cy[0]);
            sub[i][1]=(sub[i][1]&(ms[1]|~cy[1])) | (~ms[1]&cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 220 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 230: /* notsub nottag global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=(ms[0]|tag[0]);
            cam[c1][1]&=(ms[1]|tag[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(ms[0]|tag[0])) | (~ms[0]&~tag[0]);
            cam[c1][1]=(cam[c1][1]&(ms[1]|tag[1])) | (~ms[1]&~tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 230 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=(ms[0]|tag[0]);
            cam[c2][1]&=(ms[1]|tag[1]);
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&(ms[0]|tag[0])) | (~ms[0]&~tag[0]);
            cam[c2][1]=(cam[c2][1]&(ms[1]|tag[1])) | (~ms[1]&~tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 230 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)      /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=(ms[0]|tag[0]);
            sub[i][1]&=(ms[1]|tag[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(ms[0]|tag[0])) | (~ms[0]&~tag[0]);
            sub[i][1]=(sub[i][1]&(ms[1]|tag[1])) | (~ms[1]&~tag[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 230 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
    case 240: /* notsub notcy global*/
      for (i=0; i<8; i++)         /* Os 2 padroes tem 8 trits */
      {
  /**** escrita do 1.o padrao ****/
        c1=(pos1+i)%64;
        switch (patt1[7-i])
        {
          case ZERO:
            cam[c1][0]&=(ms[0]|cy[0]);
            cam[c1][1]&=(ms[1]|cy[1]);
            break;
          case UM:
            cam[c1][0]=(cam[c1][0]&(ms[0]|cy[0])) | (~ms[0]&~cy[0]);
            cam[c1][1]=(cam[c1][1]&(ms[1]|cy[1])) | (~ms[1]&~cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 240 (1o padrao). \n");
            break;
        }
  /**** escrita do 2.o padrao ****/
        c2=(pos2+i)%64;
        switch (patt2[7-i])
        {
          case ZERO:
            cam[c2][0]&=(ms[0]|cy[0]);
            cam[c2][1]&=(ms[1]|cy[1]);
            break;
          case UM:
            cam[c2][0]=(cam[c2][0]&(ms[0]|cy[0])) | (~ms[0]&~cy[0]);
            cam[c2][1]=(cam[c2][1]&(ms[1]|cy[1])) | (~ms[1]&~cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 240 (2o padrao). \n");
            break;
        }
      }
      for (i=0; i<4; i++)     /* O padrao de subset tem 4 trits */
      {
  /**** escrita do padrao de subset ****/
        switch (subset[3-i])
        {
          case ZERO:
            sub[i][0]&=(ms[0]|cy[0]);
            sub[i][1]&=(ms[1]|cy[1]);
            break;
          case UM:
            sub[i][0]=(sub[i][0]&(ms[0]|cy[0])) | (~ms[0]&~cy[0]);
            sub[i][1]=(sub[i][1]&(ms[1]|cy[1])) | (~ms[1]&~cy[1]);
          case DCARE:
            break;
          default:
	    erro ("\nErro na funcao pbl_write() // caso 240 (padrao subset). \n");
            break;
        }
      }
      break;
/******************************************************************/
   default:
   erro ("\nErro na funcao pbl_write() - codigo nao existente. \n");
   break;
/******************************************************************/
  }
}