Shamusworld >> Repos - virtualjaguar/blob - src/include/blit_c.h

   1 #ifndef blitter_code_0x30000000
   2 #define blitter_code_0x30000000
   3 void blitter_0x30000000(void)
   4 {
   5         while (outer_loop--)
   6         {
   7                 inner_loop=n_pixels;
   8                 while (inner_loop--)
   9                 {
  10                         uint32 srcdata   = 0;
  11                         uint32 srczdata  = 0;
  12                         uint32 dstdata   = 0;
  13                         uint32 dstzdata  = 0;
  14                         uint32 writedata = 0;
  15                         uint32 inhibit   = 0;
  16                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
  17                         dstdata = READ_RDATA_1(DSTDATA, a1, a1_phrase_mode);
  18                         WRITE_PIXEL_1(a1, writedata);
  19                         a1_x += a1_xadd;
  20                         a1_y += a1_yadd;
  21                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
  22                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
  23                 }
  24                 a1_x+=a1_step_x;
  25                 a1_y+=a1_step_y;
  26                 a2_x+=a2_step_x;
  27                 a2_y+=a2_step_y;
  28         }
  29         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
  30         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
  31         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
  32 }
  33 #endif
  34 #ifndef blitter_code_0x34010004
  35 #define blitter_code_0x34010004
  36 void blitter_0x34010004(void)
  37 {
  38         while (outer_loop--)
  39         {
  40                 inner_loop=n_pixels;
  41                 while (inner_loop--)
  42                 {
  43                         uint32 srcdata   = 0;
  44                         uint32 srczdata  = 0;
  45                         uint32 dstdata   = 0;
  46                         uint32 dstzdata  = 0;
  47                         uint32 writedata = 0;
  48                         uint32 inhibit   = 0;
  49                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
  50                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
  51                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
  52                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
  53                         WRITE_PIXEL_16(a1, writedata);
  54                         a1_x += a1_xadd;
  55                         a1_y += a1_yadd;
  56                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
  57                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
  58                 }
  59                 a1_x+=a1_step_x;
  60                 a1_y+=a1_step_y;
  61                 a2_x+=a2_step_x;
  62                 a2_y+=a2_step_y;
  63         }
  64         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
  65         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
  66         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
  67 }
  68 #endif
  69 #ifndef blitter_code_0x30c002a4
  70 #define blitter_code_0x30c002a4
  71 void blitter_0x30c002a4(void)
  72 {
  73         while (outer_loop--)
  74         {
  75                 inner_loop=n_pixels;
  76                 while (inner_loop--)
  77                 {
  78                         uint32 srcdata   = 0;
  79                         uint32 srczdata  = 0;
  80                         uint32 dstdata   = 0;
  81                         uint32 dstzdata  = 0;
  82                         uint32 writedata = 0;
  83                         uint32 inhibit   = 0;
  84                         srcdata = READ_PIXEL_16(a2);
  85                         dstdata = READ_PIXEL_16(a1);
  86                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
  87                                 writedata |= srcdata  & ~dstdata;
  88                                 writedata |= srcdata  & dstdata;
  89                                 {
  90                                 int intensity = srcdata & 0xFF;
  91                                 int ia = gd_ia >> 16;
  92                                 if(ia & 0x80)
  93                                         ia = 0xFFFFFF00 | ia;
  94                                 intensity += ia;
  95                                 if(intensity < 0)
  96                                         intensity = 0;
  97                                 if(intensity > 0xFF)
  98                                         intensity = 0xFF;
  99                                 writedata = (srcdata & 0xFF00) | intensity;
 100                                 }
 101                         WRITE_PIXEL_16(a1, writedata);
 102                         a1_x += a1_xadd;
 103                         a1_y += a1_yadd;
 104                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 105                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 106                         gd_i[colour_index] += gd_ia;
 107                         gd_c[colour_index] += gd_ca;
 108                          colour_index=(colour_index+1)&0x3;
 109                 }
 110                 a1_x+=a1_step_x;
 111                 a1_y+=a1_step_y;
 112                 a2_x+=a2_step_x;
 113                 a2_y+=a2_step_y;
 114         }
 115         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 116         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 117         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 118 }
 119 #endif
 120 #ifndef blitter_code_0x00c042a4
 121 #define blitter_code_0x00c042a4
 122 void blitter_0x00c042a4(void)
 123 {
 124         while (outer_loop--)
 125         {
 126                 inner_loop=n_pixels;
 127                 while (inner_loop--)
 128                 {
 129                         uint32 srcdata   = 0;
 130                         uint32 srczdata  = 0;
 131                         uint32 dstdata   = 0;
 132                         uint32 dstzdata  = 0;
 133                         uint32 writedata = 0;
 134                         uint32 inhibit   = 0;
 135                         srcdata = READ_PIXEL_16(a2);
 136                         dstdata = READ_PIXEL_16(a1);
 137                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
 138                         if (srcdata == READ_RDATA_16(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
 139                         if (!inhibit)
 140                         {
 141                                 writedata |= srcdata  & ~dstdata;
 142                                 writedata |= srcdata  & dstdata;
 143                         } else { srczdata=dstzdata; writedata=dstdata; }
 144                         if (!inhibit)
 145                         {
 146                                 WRITE_PIXEL_16(a1, writedata);
 147                         }
 148                         a1_x += a1_xadd;
 149                         a1_y += a1_yadd;
 150                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 151                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 152                 }
 153                 a1_x+=a1_step_x;
 154                 a1_y+=a1_step_y;
 155                 a2_x+=a2_step_x;
 156                 a2_y+=a2_step_y;
 157         }
 158         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 159         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 160         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 161 }
 162 #endif
 163 #ifndef blitter_code_0x08c042a4
 164 #define blitter_code_0x08c042a4
 165 void blitter_0x08c042a4(void)
 166 {
 167         while (outer_loop--)
 168         {
 169                 inner_loop=n_pixels;
 170                 while (inner_loop--)
 171                 {
 172                         uint32 srcdata   = 0;
 173                         uint32 srczdata  = 0;
 174                         uint32 dstdata   = 0;
 175                         uint32 dstzdata  = 0;
 176                         uint32 writedata = 0;
 177                         uint32 inhibit   = 0;
 178                         srcdata = READ_PIXEL_16(a2);
 179                         dstdata = READ_PIXEL_16(a1);
 180                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
 181                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
 182                         if (srcdata == READ_RDATA_16(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
 183                         if (!inhibit)
 184                         {
 185                                 writedata |= srcdata  & ~dstdata;
 186                                 writedata |= srcdata  & dstdata;
 187                         } else { srczdata=dstzdata; writedata=dstdata; }
 188                         if (!inhibit)
 189                         {
 190                                 WRITE_PIXEL_16(a1, writedata);
 191                         }
 192                         a1_x += a1_xadd;
 193                         a1_y += a1_yadd;
 194                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 195                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 196                 }
 197                 a1_x+=a1_step_x;
 198                 a1_y+=a1_step_y;
 199                 a2_x+=a2_step_x;
 200                 a2_y+=a2_step_y;
 201         }
 202         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 203         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 204         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 205 }
 206 #endif
 207 #ifndef blitter_code_0x34010024
 208 #define blitter_code_0x34010024
 209 void blitter_0x34010024(void)
 210 {
 211         while (outer_loop--)
 212         {
 213                 inner_loop=n_pixels;
 214                 while (inner_loop--)
 215                 {
 216                         uint32 srcdata   = 0;
 217                         uint32 srczdata  = 0;
 218                         uint32 dstdata   = 0;
 219                         uint32 dstzdata  = 0;
 220                         uint32 writedata = 0;
 221                         uint32 inhibit   = 0;
 222                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
 223                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
 224                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
 225                         if (!inhibit)
 226                         {
 227                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
 228                         } else { srczdata=dstzdata; writedata=dstdata; }
 229                         WRITE_PIXEL_16(a1, writedata);
 230                         a1_x += a1_xadd;
 231                         a1_y += a1_yadd;
 232                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 233                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 234                 }
 235                 a1_x+=a1_step_x;
 236                 a1_y+=a1_step_y;
 237                 a2_x+=a2_step_x;
 238                 a2_y+=a2_step_y;
 239         }
 240         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 241         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 242         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 243 }
 244 #endif
 245 #ifndef blitter_code_0x24010222
 246 #define blitter_code_0x24010222
 247 void blitter_0x24010222(void)
 248 {
 249         while (outer_loop--)
 250         {
 251                 inner_loop=n_pixels;
 252                 while (inner_loop--)
 253                 {
 254                         uint32 srcdata   = 0;
 255                         uint32 srczdata  = 0;
 256                         uint32 dstdata   = 0;
 257                         uint32 dstzdata  = 0;
 258                         uint32 writedata = 0;
 259                         uint32 inhibit   = 0;
 260                         srcdata = READ_RDATA_4(SRCDATA, a2, a2_phrase_mode);
 261                         srczdata = READ_RDATA_4(SRCZINT, a2, a2_phrase_mode);
 262                         dstdata = READ_PIXEL_4(a1);
 263                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
 264                         if (!inhibit)
 265                         {
 266                                 writedata= READ_RDATA_4(PATTERNDATA, a1, a1_phrase_mode);
 267                         } else { srczdata=dstzdata; writedata=dstdata; }
 268                         if (!inhibit)
 269                         {
 270                                 WRITE_PIXEL_4(a1, writedata);
 271                         }
 272                         a1_x += a1_xadd;
 273                         a1_y += a1_yadd;
 274                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 275                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 276                 }
 277                 a1_x+=a1_step_x;
 278                 a1_y+=a1_step_y;
 279                 a2_x+=a2_step_x;
 280                 a2_y+=a2_step_y;
 281         }
 282         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 283         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 284         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 285 }
 286 #endif
 287 #ifndef blitter_code_0x00c04292
 288 #define blitter_code_0x00c04292
 289 void blitter_0x00c04292(void)
 290 {
 291         while (outer_loop--)
 292         {
 293                 inner_loop=n_pixels;
 294                 while (inner_loop--)
 295                 {
 296                         uint32 srcdata   = 0;
 297                         uint32 srczdata  = 0;
 298                         uint32 dstdata   = 0;
 299                         uint32 dstzdata  = 0;
 300                         uint32 writedata = 0;
 301                         uint32 inhibit   = 0;
 302                         srcdata = READ_PIXEL_4(a2);
 303                         dstdata = READ_PIXEL_4(a1);
 304                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
 305                         if (srcdata == READ_RDATA_4(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
 306                         if (!inhibit)
 307                         {
 308                                 writedata |= srcdata  & ~dstdata;
 309                                 writedata |= srcdata  & dstdata;
 310                         } else { srczdata=dstzdata; writedata=dstdata; }
 311                         if (!inhibit)
 312                         {
 313                                 WRITE_PIXEL_4(a1, writedata);
 314                         }
 315                         a1_x += a1_xadd;
 316                         a1_y += a1_yadd;
 317                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 318                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 319                 }
 320                 a1_x+=a1_step_x;
 321                 a1_y+=a1_step_y;
 322                 a2_x+=a2_step_x;
 323                 a2_y+=a2_step_y;
 324         }
 325         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 326         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 327         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 328 }
 329 #endif
 330 #ifndef blitter_code_0x00c0409b
 331 #define blitter_code_0x00c0409b
 332 void blitter_0x00c0409b(void)
 333 {
 334         while (outer_loop--)
 335         {
 336                 inner_loop=n_pixels;
 337                 while (inner_loop--)
 338                 {
 339                         uint32 srcdata   = 0;
 340                         uint32 srczdata  = 0;
 341                         uint32 dstdata   = 0;
 342                         uint32 dstzdata  = 0;
 343                         uint32 writedata = 0;
 344                         uint32 inhibit   = 0;
 345                         srcdata = READ_PIXEL_8(a2);
 346                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 347                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
 348                         if (!inhibit)
 349                         {
 350                                 writedata |= srcdata  & ~dstdata;
 351                                 writedata |= srcdata  & dstdata;
 352                         } else { srczdata=dstzdata; writedata=dstdata; }
 353                         if (!inhibit)
 354                         {
 355                                 WRITE_PIXEL_8(a1, writedata);
 356                         }
 357                         a1_x += a1_xadd;
 358                         a1_y += a1_yadd;
 359                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 360                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 361                 }
 362                 a1_x+=a1_step_x;
 363                 a1_y+=a1_step_y;
 364                 a2_x+=a2_step_x;
 365                 a2_y+=a2_step_y;
 366         }
 367         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 368         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 369         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 370 }
 371 #endif
 372 #ifndef blitter_code_0x30000003
 373 #define blitter_code_0x30000003
 374 void blitter_0x30000003(void)
 375 {
 376         while (outer_loop--)
 377         {
 378                 inner_loop=n_pixels;
 379                 while (inner_loop--)
 380                 {
 381                         uint32 srcdata   = 0;
 382                         uint32 srczdata  = 0;
 383                         uint32 dstdata   = 0;
 384                         uint32 dstzdata  = 0;
 385                         uint32 writedata = 0;
 386                         uint32 inhibit   = 0;
 387                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
 388                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 389                         WRITE_PIXEL_8(a1, writedata);
 390                         a1_x += a1_xadd;
 391                         a1_y += a1_yadd;
 392                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 393                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 394                 }
 395                 a1_x+=a1_step_x;
 396                 a1_y+=a1_step_y;
 397                 a2_x+=a2_step_x;
 398                 a2_y+=a2_step_y;
 399         }
 400         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 401         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 402         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 403 }
 404 #endif
 405 #ifndef blitter_code_0x34010003
 406 #define blitter_code_0x34010003
 407 void blitter_0x34010003(void)
 408 {
 409         while (outer_loop--)
 410         {
 411                 inner_loop=n_pixels;
 412                 while (inner_loop--)
 413                 {
 414                         uint32 srcdata   = 0;
 415                         uint32 srczdata  = 0;
 416                         uint32 dstdata   = 0;
 417                         uint32 dstzdata  = 0;
 418                         uint32 writedata = 0;
 419                         uint32 inhibit   = 0;
 420                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
 421                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
 422                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 423                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
 424                         WRITE_PIXEL_8(a1, writedata);
 425                         a1_x += a1_xadd;
 426                         a1_y += a1_yadd;
 427                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 428                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 429                 }
 430                 a1_x+=a1_step_x;
 431                 a1_y+=a1_step_y;
 432                 a2_x+=a2_step_x;
 433                 a2_y+=a2_step_y;
 434         }
 435         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 436         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 437         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 438 }
 439 #endif
 440 #ifndef blitter_code_0x30c000ad
 441 #define blitter_code_0x30c000ad
 442 void blitter_0x30c000ad(void)
 443 {
 444         while (outer_loop--)
 445         {
 446                 inner_loop=n_pixels;
 447                 while (inner_loop--)
 448                 {
 449                         uint32 srcdata   = 0;
 450                         uint32 srczdata  = 0;
 451                         uint32 dstdata   = 0;
 452                         uint32 dstzdata  = 0;
 453                         uint32 writedata = 0;
 454                         uint32 inhibit   = 0;
 455                         srcdata = READ_PIXEL_32(a2);
 456                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
 457                                 writedata |= srcdata  & ~dstdata;
 458                                 writedata |= srcdata  & dstdata;
 459                         WRITE_PIXEL_32(a1, writedata);
 460                         a1_x += a1_xadd;
 461                         a1_y += a1_yadd;
 462                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 463                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 464                 }
 465                 a1_x+=a1_step_x;
 466                 a1_y+=a1_step_y;
 467                 a2_x+=a2_step_x;
 468                 a2_y+=a2_step_y;
 469         }
 470         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 471         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 472         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 473 }
 474 #endif
 475 #ifndef blitter_code_0x30c0009b
 476 #define blitter_code_0x30c0009b
 477 void blitter_0x30c0009b(void)
 478 {
 479         while (outer_loop--)
 480         {
 481                 inner_loop=n_pixels;
 482                 while (inner_loop--)
 483                 {
 484                         uint32 srcdata   = 0;
 485                         uint32 srczdata  = 0;
 486                         uint32 dstdata   = 0;
 487                         uint32 dstzdata  = 0;
 488                         uint32 writedata = 0;
 489                         uint32 inhibit   = 0;
 490                         srcdata = READ_PIXEL_8(a2);
 491                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 492                                 writedata |= srcdata  & ~dstdata;
 493                                 writedata |= srcdata  & dstdata;
 494                         WRITE_PIXEL_8(a1, writedata);
 495                         a1_x += a1_xadd;
 496                         a1_y += a1_yadd;
 497                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 498                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 499                 }
 500                 a1_x+=a1_step_x;
 501                 a1_y+=a1_step_y;
 502                 a2_x+=a2_step_x;
 503                 a2_y+=a2_step_y;
 504         }
 505         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 506         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 507         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 508 }
 509 #endif
 510 #ifndef blitter_code_0x3401001b
 511 #define blitter_code_0x3401001b
 512 void blitter_0x3401001b(void)
 513 {
 514         while (outer_loop--)
 515         {
 516                 inner_loop=n_pixels;
 517                 while (inner_loop--)
 518                 {
 519                         uint32 srcdata   = 0;
 520                         uint32 srczdata  = 0;
 521                         uint32 dstdata   = 0;
 522                         uint32 dstzdata  = 0;
 523                         uint32 writedata = 0;
 524                         uint32 inhibit   = 0;
 525                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
 526                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
 527                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 528                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
 529                         WRITE_PIXEL_8(a1, writedata);
 530                         a1_x += a1_xadd;
 531                         a1_y += a1_yadd;
 532                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 533                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 534                 }
 535                 a1_x+=a1_step_x;
 536                 a1_y+=a1_step_y;
 537                 a2_x+=a2_step_x;
 538                 a2_y+=a2_step_y;
 539         }
 540         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 541         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 542         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 543 }
 544 #endif
 545 #ifndef blitter_code_0x30c000a4
 546 #define blitter_code_0x30c000a4
 547 void blitter_0x30c000a4(void)
 548 {
 549         while (outer_loop--)
 550         {
 551                 inner_loop=n_pixels;
 552                 while (inner_loop--)
 553                 {
 554                         uint32 srcdata   = 0;
 555                         uint32 srczdata  = 0;
 556                         uint32 dstdata   = 0;
 557                         uint32 dstzdata  = 0;
 558                         uint32 writedata = 0;
 559                         uint32 inhibit   = 0;
 560                         srcdata = READ_PIXEL_16(a2);
 561                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
 562                                 writedata |= srcdata  & ~dstdata;
 563                                 writedata |= srcdata  & dstdata;
 564                         WRITE_PIXEL_16(a1, writedata);
 565                         a1_x += a1_xadd;
 566                         a1_y += a1_yadd;
 567                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 568                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 569                 }
 570                 a1_x+=a1_step_x;
 571                 a1_y+=a1_step_y;
 572                 a2_x+=a2_step_x;
 573                 a2_y+=a2_step_y;
 574         }
 575         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 576         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 577         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 578 }
 579 #endif
 580 #ifndef blitter_code_0x34010023
 581 #define blitter_code_0x34010023
 582 void blitter_0x34010023(void)
 583 {
 584         while (outer_loop--)
 585         {
 586                 inner_loop=n_pixels;
 587                 while (inner_loop--)
 588                 {
 589                         uint32 srcdata   = 0;
 590                         uint32 srczdata  = 0;
 591                         uint32 dstdata   = 0;
 592                         uint32 dstzdata  = 0;
 593                         uint32 writedata = 0;
 594                         uint32 inhibit   = 0;
 595                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
 596                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
 597                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 598                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
 599                         WRITE_PIXEL_8(a1, writedata);
 600                         a1_x += a1_xadd;
 601                         a1_y += a1_yadd;
 602                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 603                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 604                 }
 605                 a1_x+=a1_step_x;
 606                 a1_y+=a1_step_y;
 607                 a2_x+=a2_step_x;
 608                 a2_y+=a2_step_y;
 609         }
 610         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 611         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 612         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 613 }
 614 #endif
 615 #ifndef blitter_code_0x30000023
 616 #define blitter_code_0x30000023
 617 void blitter_0x30000023(void)
 618 {
 619         while (outer_loop--)
 620         {
 621                 inner_loop=n_pixels;
 622                 while (inner_loop--)
 623                 {
 624                         uint32 srcdata   = 0;
 625                         uint32 srczdata  = 0;
 626                         uint32 dstdata   = 0;
 627                         uint32 dstzdata  = 0;
 628                         uint32 writedata = 0;
 629                         uint32 inhibit   = 0;
 630                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
 631                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 632                         WRITE_PIXEL_8(a1, writedata);
 633                         a1_x += a1_xadd;
 634                         a1_y += a1_yadd;
 635                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 636                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 637                 }
 638                 a1_x+=a1_step_x;
 639                 a1_y+=a1_step_y;
 640                 a2_x+=a2_step_x;
 641                 a2_y+=a2_step_y;
 642         }
 643         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 644         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 645         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 646 }
 647 #endif
 648 #ifndef blitter_code_0x24010024
 649 #define blitter_code_0x24010024
 650 void blitter_0x24010024(void)
 651 {
 652         while (outer_loop--)
 653         {
 654                 inner_loop=n_pixels;
 655                 while (inner_loop--)
 656                 {
 657                         uint32 srcdata   = 0;
 658                         uint32 srczdata  = 0;
 659                         uint32 dstdata   = 0;
 660                         uint32 dstzdata  = 0;
 661                         uint32 writedata = 0;
 662                         uint32 inhibit   = 0;
 663                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
 664                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
 665                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
 666                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
 667                                 WRITE_PIXEL_16(a1, writedata);
 668                         a1_x += a1_xadd;
 669                         a1_y += a1_yadd;
 670                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 671                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 672                 }
 673                 a1_x+=a1_step_x;
 674                 a1_y+=a1_step_y;
 675                 a2_x+=a2_step_x;
 676                 a2_y+=a2_step_y;
 677         }
 678         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 679         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 680         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 681 }
 682 #endif
 683 #ifndef blitter_code_0x00c000a4
 684 #define blitter_code_0x00c000a4
 685 void blitter_0x00c000a4(void)
 686 {
 687         while (outer_loop--)
 688         {
 689                 inner_loop=n_pixels;
 690                 while (inner_loop--)
 691                 {
 692                         uint32 srcdata   = 0;
 693                         uint32 srczdata  = 0;
 694                         uint32 dstdata   = 0;
 695                         uint32 dstzdata  = 0;
 696                         uint32 writedata = 0;
 697                         uint32 inhibit   = 0;
 698                         srcdata = READ_PIXEL_16(a2);
 699                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
 700                                 writedata |= srcdata  & ~dstdata;
 701                                 writedata |= srcdata  & dstdata;
 702                                 WRITE_PIXEL_16(a1, writedata);
 703                         a1_x += a1_xadd;
 704                         a1_y += a1_yadd;
 705                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 706                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 707                 }
 708                 a1_x+=a1_step_x;
 709                 a1_y+=a1_step_y;
 710                 a2_x+=a2_step_x;
 711                 a2_y+=a2_step_y;
 712         }
 713         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 714         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 715         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 716 }
 717 #endif
 718 #ifndef blitter_code_0x00c040a4
 719 #define blitter_code_0x00c040a4
 720 void blitter_0x00c040a4(void)
 721 {
 722         while (outer_loop--)
 723         {
 724                 inner_loop=n_pixels;
 725                 while (inner_loop--)
 726                 {
 727                         uint32 srcdata   = 0;
 728                         uint32 srczdata  = 0;
 729                         uint32 dstdata   = 0;
 730                         uint32 dstzdata  = 0;
 731                         uint32 writedata = 0;
 732                         uint32 inhibit   = 0;
 733                         srcdata = READ_PIXEL_16(a2);
 734                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
 735                         if (srcdata == READ_RDATA_16(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
 736                         if (!inhibit)
 737                         {
 738                                 writedata |= srcdata  & ~dstdata;
 739                                 writedata |= srcdata  & dstdata;
 740                         } else { srczdata=dstzdata; writedata=dstdata; }
 741                         if (!inhibit)
 742                         {
 743                                 WRITE_PIXEL_16(a1, writedata);
 744                         }
 745                         a1_x += a1_xadd;
 746                         a1_y += a1_yadd;
 747                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 748                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 749                 }
 750                 a1_x+=a1_step_x;
 751                 a1_y+=a1_step_y;
 752                 a2_x+=a2_step_x;
 753                 a2_y+=a2_step_y;
 754         }
 755         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 756         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 757         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 758 }
 759 #endif
 760 #ifndef blitter_code_0x04010024
 761 #define blitter_code_0x04010024
 762 void blitter_0x04010024(void)
 763 {
 764         while (outer_loop--)
 765         {
 766                 inner_loop=n_pixels;
 767                 while (inner_loop--)
 768                 {
 769                         uint32 srcdata   = 0;
 770                         uint32 srczdata  = 0;
 771                         uint32 dstdata   = 0;
 772                         uint32 dstzdata  = 0;
 773                         uint32 writedata = 0;
 774                         uint32 inhibit   = 0;
 775                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
 776                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
 777                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
 778                         if (!inhibit)
 779                         {
 780                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
 781                         } else { srczdata=dstzdata; writedata=dstdata; }
 782                         if (!inhibit)
 783                         {
 784                                 WRITE_PIXEL_16(a1, writedata);
 785                         }
 786                         a1_x += a1_xadd;
 787                         a1_y += a1_yadd;
 788                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 789                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 790                 }
 791                 a1_x+=a1_step_x;
 792                 a1_y+=a1_step_y;
 793                 a2_x+=a2_step_x;
 794                 a2_y+=a2_step_y;
 795         }
 796         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 797         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 798         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 799 }
 800 #endif
 801 #ifndef blitter_code_0x2401001c
 802 #define blitter_code_0x2401001c
 803 void blitter_0x2401001c(void)
 804 {
 805         while (outer_loop--)
 806         {
 807                 inner_loop=n_pixels;
 808                 while (inner_loop--)
 809                 {
 810                         uint32 srcdata   = 0;
 811                         uint32 srczdata  = 0;
 812                         uint32 dstdata   = 0;
 813                         uint32 dstzdata  = 0;
 814                         uint32 writedata = 0;
 815                         uint32 inhibit   = 0;
 816                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
 817                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
 818                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
 819                         if (!inhibit)
 820                         {
 821                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
 822                         } else { srczdata=dstzdata; writedata=dstdata; }
 823                         if (!inhibit)
 824                         {
 825                                 WRITE_PIXEL_16(a1, writedata);
 826                         }
 827                         a1_x += a1_xadd;
 828                         a1_y += a1_yadd;
 829                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 830                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 831                 }
 832                 a1_x+=a1_step_x;
 833                 a1_y+=a1_step_y;
 834                 a2_x+=a2_step_x;
 835                 a2_y+=a2_step_y;
 836         }
 837         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 838         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 839         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 840 }
 841 #endif
 842 #ifndef blitter_code_0x3000002b
 843 #define blitter_code_0x3000002b
 844 void blitter_0x3000002b(void)
 845 {
 846         while (outer_loop--)
 847         {
 848                 inner_loop=n_pixels;
 849                 while (inner_loop--)
 850                 {
 851                         uint32 srcdata   = 0;
 852                         uint32 srczdata  = 0;
 853                         uint32 dstdata   = 0;
 854                         uint32 dstzdata  = 0;
 855                         uint32 writedata = 0;
 856                         uint32 inhibit   = 0;
 857                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
 858                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 859                         if (!inhibit)
 860                         {
 861                         } else { srczdata=dstzdata; writedata=dstdata; }
 862                         WRITE_PIXEL_8(a1, writedata);
 863                         a1_x += a1_xadd;
 864                         a1_y += a1_yadd;
 865                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 866                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 867                 }
 868                 a1_x+=a1_step_x;
 869                 a1_y+=a1_step_y;
 870                 a2_x+=a2_step_x;
 871                 a2_y+=a2_step_y;
 872         }
 873         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 874         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 875         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 876 }
 877 #endif
 878 #ifndef blitter_code_0x3000001b
 879 #define blitter_code_0x3000001b
 880 void blitter_0x3000001b(void)
 881 {
 882         while (outer_loop--)
 883         {
 884                 inner_loop=n_pixels;
 885                 while (inner_loop--)
 886                 {
 887                         uint32 srcdata   = 0;
 888                         uint32 srczdata  = 0;
 889                         uint32 dstdata   = 0;
 890                         uint32 dstzdata  = 0;
 891                         uint32 writedata = 0;
 892                         uint32 inhibit   = 0;
 893                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
 894                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 895                         if (!inhibit)
 896                         {
 897                         } else { srczdata=dstzdata; writedata=dstdata; }
 898                         WRITE_PIXEL_8(a1, writedata);
 899                         a1_x += a1_xadd;
 900                         a1_y += a1_yadd;
 901                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 902                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 903                 }
 904                 a1_x+=a1_step_x;
 905                 a1_y+=a1_step_y;
 906                 a2_x+=a2_step_x;
 907                 a2_y+=a2_step_y;
 908         }
 909         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 910         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 911         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 912 }
 913 #endif
 914 #ifndef blitter_code_0x00c0009b
 915 #define blitter_code_0x00c0009b
 916 void blitter_0x00c0009b(void)
 917 {
 918         while (outer_loop--)
 919         {
 920                 inner_loop=n_pixels;
 921                 while (inner_loop--)
 922                 {
 923                         uint32 srcdata   = 0;
 924                         uint32 srczdata  = 0;
 925                         uint32 dstdata   = 0;
 926                         uint32 dstzdata  = 0;
 927                         uint32 writedata = 0;
 928                         uint32 inhibit   = 0;
 929                         srcdata = READ_PIXEL_8(a2);
 930                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 931                         if (!inhibit)
 932                         {
 933                                 writedata |= srcdata  & ~dstdata;
 934                                 writedata |= srcdata  & dstdata;
 935                         } else { srczdata=dstzdata; writedata=dstdata; }
 936                         if (!inhibit)
 937                         {
 938                                 WRITE_PIXEL_8(a1, writedata);
 939                         }
 940                         a1_x += a1_xadd;
 941                         a1_y += a1_yadd;
 942                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 943                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 944                 }
 945                 a1_x+=a1_step_x;
 946                 a1_y+=a1_step_y;
 947                 a2_x+=a2_step_x;
 948                 a2_y+=a2_step_y;
 949         }
 950         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 951         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 952         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 953 }
 954 #endif
 955 #ifndef blitter_code_0x1000001b
 956 #define blitter_code_0x1000001b
 957 void blitter_0x1000001b(void)
 958 {
 959         while (outer_loop--)
 960         {
 961                 inner_loop=n_pixels;
 962                 while (inner_loop--)
 963                 {
 964                         uint32 srcdata   = 0;
 965                         uint32 srczdata  = 0;
 966                         uint32 dstdata   = 0;
 967                         uint32 dstzdata  = 0;
 968                         uint32 writedata = 0;
 969                         uint32 inhibit   = 0;
 970                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
 971                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
 972                         if (!inhibit)
 973                         {
 974                         } else { srczdata=dstzdata; writedata=dstdata; }
 975                         WRITE_PIXEL_8(a1, writedata);
 976                         a1_x += a1_xadd;
 977                         a1_y += a1_yadd;
 978                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
 979                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
 980                 }
 981                 a1_x+=a1_step_x;
 982                 a1_y+=a1_step_y;
 983                 a2_x+=a2_step_x;
 984                 a2_y+=a2_step_y;
 985         }
 986         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
 987         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
 988         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
 989 }
 990 #endif
 991 #ifndef blitter_code_0x10000023
 992 #define blitter_code_0x10000023
 993 void blitter_0x10000023(void)
 994 {
 995         while (outer_loop--)
 996         {
 997                 inner_loop=n_pixels;
 998                 while (inner_loop--)
 999                 {
1000                         uint32 srcdata   = 0;
1001                         uint32 srczdata  = 0;
1002                         uint32 dstdata   = 0;
1003                         uint32 dstzdata  = 0;
1004                         uint32 writedata = 0;
1005                         uint32 inhibit   = 0;
1006                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
1007                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
1008                         if (!inhibit)
1009                         {
1010                         } else { srczdata=dstzdata; writedata=dstdata; }
1011                         WRITE_PIXEL_8(a1, writedata);
1012                         a1_x += a1_xadd;
1013                         a1_y += a1_yadd;
1014                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1015                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1016                 }
1017                 a1_x+=a1_step_x;
1018                 a1_y+=a1_step_y;
1019                 a2_x+=a2_step_x;
1020                 a2_y+=a2_step_y;
1021         }
1022         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1023         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1024         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1025 }
1026 #endif
1027 #ifndef blitter_code_0x3401001d
1028 #define blitter_code_0x3401001d
1029 void blitter_0x3401001d(void)
1030 {
1031         while (outer_loop--)
1032         {
1033                 inner_loop=n_pixels;
1034                 while (inner_loop--)
1035                 {
1036                         uint32 srcdata   = 0;
1037                         uint32 srczdata  = 0;
1038                         uint32 dstdata   = 0;
1039                         uint32 dstzdata  = 0;
1040                         uint32 writedata = 0;
1041                         uint32 inhibit   = 0;
1042                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
1043                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
1044                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
1045                         if (!inhibit)
1046                         {
1047                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
1048                         } else { srczdata=dstzdata; writedata=dstdata; }
1049                         WRITE_PIXEL_32(a1, writedata);
1050                         a1_x += a1_xadd;
1051                         a1_y += a1_yadd;
1052                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1053                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1054                 }
1055                 a1_x+=a1_step_x;
1056                 a1_y+=a1_step_y;
1057                 a2_x+=a2_step_x;
1058                 a2_y+=a2_step_y;
1059         }
1060         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1061         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1062         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1063 }
1064 #endif
1065 #ifndef blitter_code_0x00c000e4
1066 #define blitter_code_0x00c000e4
1067 void blitter_0x00c000e4(void)
1068 {
1069         while (outer_loop--)
1070         {
1071                 inner_loop=n_pixels;
1072                 while (inner_loop--)
1073                 {
1074                         uint32 srcdata   = 0;
1075                         uint32 srczdata  = 0;
1076                         uint32 dstdata   = 0;
1077                         uint32 dstzdata  = 0;
1078                         uint32 writedata = 0;
1079                         uint32 inhibit   = 0;
1080                         srcdata = READ_PIXEL_16(a1);
1081                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
1082                         srczdata=z_i[colour_index]>>16;
1083                         if (!inhibit)
1084                         {
1085                                 writedata |= srcdata  & ~dstdata;
1086                                 writedata |= srcdata  & dstdata;
1087                                 {
1088                                 int intensity = srcdata & 0xFF;
1089                                 int ia = gd_ia >> 16;
1090                                 if(ia & 0x80)
1091                                         ia = 0xFFFFFF00 | ia;
1092                                 intensity += ia;
1093                                 if(intensity < 0)
1094                                         intensity = 0;
1095                                 if(intensity > 0xFF)
1096                                         intensity = 0xFF;
1097                                 writedata = (srcdata & 0xFF00) | intensity;
1098                                 }
1099                         } else { srczdata=dstzdata; writedata=dstdata; }
1100                         if (!inhibit)
1101                         {
1102                                 WRITE_PIXEL_16(a2, writedata);
1103                         }
1104                         a1_x += a1_xadd;
1105                         a1_y += a1_yadd;
1106                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1107                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1108                         z_i[colour_index]+=zadd;
1109                         gd_i[colour_index] += gd_ia;
1110                         gd_c[colour_index] += gd_ca;
1111                 }
1112                 a1_x+=a1_step_x;
1113                 a1_y+=a1_step_y;
1114                 a2_x+=a2_step_x;
1115                 a2_y+=a2_step_y;
1116         }
1117         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1118         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1119         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1120 }
1121 #endif
1122 #ifndef blitter_code_0x24010064
1123 #define blitter_code_0x24010064
1124 void blitter_0x24010064(void)
1125 {
1126         while (outer_loop--)
1127         {
1128                 inner_loop=n_pixels;
1129                 while (inner_loop--)
1130                 {
1131                         uint32 srcdata   = 0;
1132                         uint32 srczdata  = 0;
1133                         uint32 dstdata   = 0;
1134                         uint32 dstzdata  = 0;
1135                         uint32 writedata = 0;
1136                         uint32 inhibit   = 0;
1137                         srcdata = READ_RDATA_16(SRCDATA, a1, a1_phrase_mode);
1138                         srczdata = READ_RDATA_16(SRCZINT, a1, a1_phrase_mode);
1139                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
1140                         if (!inhibit)
1141                         {
1142                                 writedata= READ_RDATA_16(PATTERNDATA, a2, a2_phrase_mode);
1143                         } else { srczdata=dstzdata; writedata=dstdata; }
1144                         WRITE_PIXEL_16(a2, writedata);
1145                         a1_x += a1_xadd;
1146                         a1_y += a1_yadd;
1147                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1148                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1149                 }
1150                 a1_x+=a1_step_x;
1151                 a1_y+=a1_step_y;
1152                 a2_x+=a2_step_x;
1153                 a2_y+=a2_step_y;
1154         }
1155         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1156         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1157         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1158 }
1159 #endif
1160 #ifndef blitter_code_0x00c040e4
1161 #define blitter_code_0x00c040e4
1162 void blitter_0x00c040e4(void)
1163 {
1164         while (outer_loop--)
1165         {
1166                 inner_loop=n_pixels;
1167                 while (inner_loop--)
1168                 {
1169                         uint32 srcdata   = 0;
1170                         uint32 srczdata  = 0;
1171                         uint32 dstdata   = 0;
1172                         uint32 dstzdata  = 0;
1173                         uint32 writedata = 0;
1174                         uint32 inhibit   = 0;
1175                         srcdata = READ_PIXEL_16(a1);
1176                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
1177                         if (srcdata == READ_RDATA_16(PATTERNDATA, a1,a1_phrase_mode)) inhibit=1;
1178                         if (!inhibit)
1179                         {
1180                                 writedata |= srcdata  & ~dstdata;
1181                                 writedata |= srcdata  & dstdata;
1182                                 {
1183                                 int intensity = srcdata & 0xFF;
1184                                 int ia = gd_ia >> 16;
1185                                 if(ia & 0x80)
1186                                         ia = 0xFFFFFF00 | ia;
1187                                 intensity += ia;
1188                                 if(intensity < 0)
1189                                         intensity = 0;
1190                                 if(intensity > 0xFF)
1191                                         intensity = 0xFF;
1192                                 writedata = (srcdata & 0xFF00) | intensity;
1193                                 }
1194                         } else { srczdata=dstzdata; writedata=dstdata; }
1195                         if (!inhibit)
1196                         {
1197                                 WRITE_PIXEL_16(a2, writedata);
1198                         }
1199                         a1_x += a1_xadd;
1200                         a1_y += a1_yadd;
1201                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1202                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1203                         gd_i[colour_index] += gd_ia;
1204                         gd_c[colour_index] += gd_ca;
1205                 }
1206                 a1_x+=a1_step_x;
1207                 a1_y+=a1_step_y;
1208                 a2_x+=a2_step_x;
1209                 a2_y+=a2_step_y;
1210         }
1211         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1212         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1213         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1214 }
1215 #endif
1216 #ifndef blitter_code_0x2000002b
1217 #define blitter_code_0x2000002b
1218 void blitter_0x2000002b(void)
1219 {
1220         while (outer_loop--)
1221         {
1222                 inner_loop=n_pixels;
1223                 while (inner_loop--)
1224                 {
1225                         uint32 srcdata   = 0;
1226                         uint32 srczdata  = 0;
1227                         uint32 dstdata   = 0;
1228                         uint32 dstzdata  = 0;
1229                         uint32 writedata = 0;
1230                         uint32 inhibit   = 0;
1231                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
1232                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
1233                         if (!inhibit)
1234                         {
1235                         } else { srczdata=dstzdata; writedata=dstdata; }
1236                         if (!inhibit)
1237                         {
1238                                 WRITE_PIXEL_8(a1, writedata);
1239                         }
1240                         a1_x += a1_xadd;
1241                         a1_y += a1_yadd;
1242                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1243                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1244                 }
1245                 a1_x+=a1_step_x;
1246                 a1_y+=a1_step_y;
1247                 a2_x+=a2_step_x;
1248                 a2_y+=a2_step_y;
1249         }
1250         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1251         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1252         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1253 }
1254 #endif
1255 #ifndef blitter_code_0x00a00058
1256 #define blitter_code_0x00a00058
1257 void blitter_0x00a00058(void)
1258 {
1259         while (outer_loop--)
1260         {
1261                 inner_loop=n_pixels;
1262                 while (inner_loop--)
1263                 {
1264                         uint32 srcdata   = 0;
1265                         uint32 srczdata  = 0;
1266                         uint32 dstdata   = 0;
1267                         uint32 dstzdata  = 0;
1268                         uint32 writedata = 0;
1269                         uint32 inhibit   = 0;
1270                         srcdata = READ_RDATA_8(SRCDATA, a1, a1_phrase_mode);
1271                         dstdata = READ_RDATA_8(DSTDATA, a2, a2_phrase_mode);
1272                         if (!inhibit)
1273                         {
1274                                 writedata |= ~srcdata & dstdata;
1275                                 writedata |= srcdata  & dstdata;
1276                         } else { srczdata=dstzdata; writedata=dstdata; }
1277                         if (!inhibit)
1278                         {
1279                                 WRITE_PIXEL_8(a2, writedata);
1280                         }
1281                         a1_x += a1_xadd;
1282                         a1_y += a1_yadd;
1283                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1284                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1285                 }
1286                 a1_x+=a1_step_x;
1287                 a1_y+=a1_step_y;
1288                 a2_x+=a2_step_x;
1289                 a2_y+=a2_step_y;
1290         }
1291         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1292         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1293         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1294 }
1295 #endif
1296 #ifndef blitter_code_0x050100d8
1297 #define blitter_code_0x050100d8
1298 void blitter_0x050100d8(void)
1299 {
1300         while (outer_loop--)
1301         {
1302                 inner_loop=n_pixels;
1303                 while (inner_loop--)
1304                 {
1305                         uint32 srcdata   = 0;
1306                         uint32 srczdata  = 0;
1307                         uint32 dstdata   = 0;
1308                         uint32 dstzdata  = 0;
1309                         uint32 writedata = 0;
1310                         uint32 inhibit   = 0;
1311                         srcdata = READ_PIXEL_8(a1);
1312                         srczdata = READ_RDATA_1(SRCZINT, a1, a1_phrase_mode);
1313                         dstdata = READ_RDATA_8(DSTDATA, a2, a2_phrase_mode);
1314                         if (!inhibit)
1315                         {
1316                                 writedata= READ_RDATA_8(PATTERNDATA, a2, a2_phrase_mode);
1317                         } else { srczdata=dstzdata; writedata=dstdata; }
1318                         WRITE_PIXEL_8(a2, writedata);
1319                         a1_x += a1_xadd;
1320                         a1_y += a1_yadd;
1321                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1322                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1323                 }
1324                 a1_x+=a1_step_x;
1325                 a1_y+=a1_step_y;
1326                 a2_x+=a2_step_x;
1327                 a2_y+=a2_step_y;
1328         }
1329         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1330         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1331         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1332 }
1333 #endif
1334 #ifndef blitter_code_0x00c00280
1335 #define blitter_code_0x00c00280
1336 void blitter_0x00c00280(void)
1337 {
1338         while (outer_loop--)
1339         {
1340                 inner_loop=n_pixels;
1341                 while (inner_loop--)
1342                 {
1343                         uint32 srcdata   = 0;
1344                         uint32 srczdata  = 0;
1345                         uint32 dstdata   = 0;
1346                         uint32 dstzdata  = 0;
1347                         uint32 writedata = 0;
1348                         uint32 inhibit   = 0;
1349                         srcdata = READ_PIXEL_1(a2);
1350                         dstdata = READ_PIXEL_1(a1);
1351                         dstzdata = READ_RDATA_1(DSTZ, a1, a1_phrase_mode);
1352                         if (!inhibit)
1353                         {
1354                                 writedata |= srcdata  & ~dstdata;
1355                                 writedata |= srcdata  & dstdata;
1356                         } else { srczdata=dstzdata; writedata=dstdata; }
1357                         if (!inhibit)
1358                         {
1359                                 WRITE_PIXEL_1(a1, writedata);
1360                         }
1361                         a1_x += a1_xadd;
1362                         a1_y += a1_yadd;
1363                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1364                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1365                 }
1366                 a1_x+=a1_step_x;
1367                 a1_y+=a1_step_y;
1368                 a2_x+=a2_step_x;
1369                 a2_y+=a2_step_y;
1370         }
1371         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1372         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1373         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1374 }
1375 #endif
1376 #ifndef blitter_code_0x04010064
1377 #define blitter_code_0x04010064
1378 void blitter_0x04010064(void)
1379 {
1380         while (outer_loop--)
1381         {
1382                 inner_loop=n_pixels;
1383                 while (inner_loop--)
1384                 {
1385                         uint32 srcdata   = 0;
1386                         uint32 srczdata  = 0;
1387                         uint32 dstdata   = 0;
1388                         uint32 dstzdata  = 0;
1389                         uint32 writedata = 0;
1390                         uint32 inhibit   = 0;
1391                         srcdata = READ_RDATA_16(SRCDATA, a1, a1_phrase_mode);
1392                         srczdata = READ_RDATA_16(SRCZINT, a1, a1_phrase_mode);
1393                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
1394                         if (!inhibit)
1395                         {
1396                                 writedata= READ_RDATA_16(PATTERNDATA, a2, a2_phrase_mode);
1397                         } else { srczdata=dstzdata; writedata=dstdata; }
1398                         if (!inhibit)
1399                         {
1400                                 WRITE_PIXEL_16(a2, writedata);
1401                         }
1402                         a1_x += a1_xadd;
1403                         a1_y += a1_yadd;
1404                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1405                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1406                 }
1407                 a1_x+=a1_step_x;
1408                 a1_y+=a1_step_y;
1409                 a2_x+=a2_step_x;
1410                 a2_y+=a2_step_y;
1411         }
1412         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1413         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1414         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1415 }
1416 #endif
1417 #ifndef blitter_code_0x24010003
1418 #define blitter_code_0x24010003
1419 void blitter_0x24010003(void)
1420 {
1421         while (outer_loop--)
1422         {
1423                 inner_loop=n_pixels;
1424                 while (inner_loop--)
1425                 {
1426                         uint32 srcdata   = 0;
1427                         uint32 srczdata  = 0;
1428                         uint32 dstdata   = 0;
1429                         uint32 dstzdata  = 0;
1430                         uint32 writedata = 0;
1431                         uint32 inhibit   = 0;
1432                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
1433                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
1434                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
1435                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
1436                                 WRITE_PIXEL_8(a1, writedata);
1437                         a1_x += a1_xadd;
1438                         a1_y += a1_yadd;
1439                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1440                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1441                 }
1442                 a1_x+=a1_step_x;
1443                 a1_y+=a1_step_y;
1444                 a2_x+=a2_step_x;
1445                 a2_y+=a2_step_y;
1446         }
1447         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1448         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1449         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1450 }
1451 #endif
1452 #ifndef blitter_code_0x24010023
1453 #define blitter_code_0x24010023
1454 void blitter_0x24010023(void)
1455 {
1456         while (outer_loop--)
1457         {
1458                 inner_loop=n_pixels;
1459                 while (inner_loop--)
1460                 {
1461                         uint32 srcdata   = 0;
1462                         uint32 srczdata  = 0;
1463                         uint32 dstdata   = 0;
1464                         uint32 dstzdata  = 0;
1465                         uint32 writedata = 0;
1466                         uint32 inhibit   = 0;
1467                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
1468                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
1469                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
1470                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
1471                                 WRITE_PIXEL_8(a1, writedata);
1472                         a1_x += a1_xadd;
1473                         a1_y += a1_yadd;
1474                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1475                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1476                 }
1477                 a1_x+=a1_step_x;
1478                 a1_y+=a1_step_y;
1479                 a2_x+=a2_step_x;
1480                 a2_y+=a2_step_y;
1481         }
1482         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1483         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1484         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1485 }
1486 #endif
1487 #ifndef blitter_code_0x00c0429b
1488 #define blitter_code_0x00c0429b
1489 void blitter_0x00c0429b(void)
1490 {
1491         while (outer_loop--)
1492         {
1493                 inner_loop=n_pixels;
1494                 while (inner_loop--)
1495                 {
1496                         uint32 srcdata   = 0;
1497                         uint32 srczdata  = 0;
1498                         uint32 dstdata   = 0;
1499                         uint32 dstzdata  = 0;
1500                         uint32 writedata = 0;
1501                         uint32 inhibit   = 0;
1502                         srcdata = READ_PIXEL_8(a2);
1503                         dstdata = READ_PIXEL_8(a1);
1504                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
1505                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
1506                         if (!inhibit)
1507                         {
1508                                 writedata |= srcdata  & ~dstdata;
1509                                 writedata |= srcdata  & dstdata;
1510                         } else { srczdata=dstzdata; writedata=dstdata; }
1511                         if (!inhibit)
1512                         {
1513                                 WRITE_PIXEL_8(a1, writedata);
1514                         }
1515                         a1_x += a1_xadd;
1516                         a1_y += a1_yadd;
1517                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1518                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1519                 }
1520                 a1_x+=a1_step_x;
1521                 a1_y+=a1_step_y;
1522                 a2_x+=a2_step_x;
1523                 a2_y+=a2_step_y;
1524         }
1525         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1526         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1527         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1528 }
1529 #endif
1530 #ifndef blitter_code_0x00c042db
1531 #define blitter_code_0x00c042db
1532 void blitter_0x00c042db(void)
1533 {
1534         uint32 srcdata   = 0;
1535         uint32 srczdata  = 0;
1536         uint32 dstdata   = 0;
1537         uint32 dstzdata  = 0;
1538         uint32 writedata = 0;
1539         uint32 inhibit   = 0;
1540         uint32 compare_value=READ_RDATA_8(PATTERNDATA, a1,a1_phrase_mode);
1541
1542         while (outer_loop--)
1543         {
1544                 inner_loop=n_pixels;
1545                 while (inner_loop--)
1546                 {
1547                         srcdata   = 0;
1548                         writedata = 0;
1549
1550                         srcdata = READ_PIXEL_8(a1);
1551                         if (srcdata != compare_value )
1552                         {
1553                                 dstdata = READ_PIXEL_8(a2);
1554                                 writedata |= srcdata  & ~dstdata;
1555                                 writedata |= srcdata  & dstdata;
1556                                 WRITE_PIXEL_8(a2, writedata);
1557                         }
1558                         a1_x += a1_xadd;
1559                         a1_y += a1_yadd;
1560                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1561                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1562                 }
1563                 a1_x+=a1_step_x;
1564                 a1_y+=a1_step_y;
1565                 a2_x+=a2_step_x;
1566                 a2_y+=a2_step_y;
1567         }
1568         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1569         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1570         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1571 }
1572 #endif
1573 #ifndef blitter_code_0x1401001b
1574 #define blitter_code_0x1401001b
1575 void blitter_0x1401001b(void)
1576 {
1577         while (outer_loop--)
1578         {
1579                 inner_loop=n_pixels;
1580                 while (inner_loop--)
1581                 {
1582                         uint32 srcdata   = 0;
1583                         uint32 srczdata  = 0;
1584                         uint32 dstdata   = 0;
1585                         uint32 dstzdata  = 0;
1586                         uint32 writedata = 0;
1587                         uint32 inhibit   = 0;
1588                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
1589                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
1590                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
1591                         if (!inhibit)
1592                         {
1593                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
1594                         } else { srczdata=dstzdata; writedata=dstdata; }
1595                         WRITE_PIXEL_8(a1, writedata);
1596                         a1_x += a1_xadd;
1597                         a1_y += a1_yadd;
1598                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1599                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1600                 }
1601                 a1_x+=a1_step_x;
1602                 a1_y+=a1_step_y;
1603                 a2_x+=a2_step_x;
1604                 a2_y+=a2_step_y;
1605         }
1606         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1607         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1608         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1609 }
1610 #endif
1611 #ifndef blitter_code_0x24010004
1612 #define blitter_code_0x24010004
1613 void blitter_0x24010004(void)
1614 {
1615         while (outer_loop--)
1616         {
1617                 inner_loop=n_pixels;
1618                 while (inner_loop--)
1619                 {
1620                         uint32 srcdata   = 0;
1621                         uint32 srczdata  = 0;
1622                         uint32 dstdata   = 0;
1623                         uint32 dstzdata  = 0;
1624                         uint32 writedata = 0;
1625                         uint32 inhibit   = 0;
1626                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
1627                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
1628                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
1629                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
1630                                 WRITE_PIXEL_16(a1, writedata);
1631                         a1_x += a1_xadd;
1632                         a1_y += a1_yadd;
1633                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1634                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1635                 }
1636                 a1_x+=a1_step_x;
1637                 a1_y+=a1_step_y;
1638                 a2_x+=a2_step_x;
1639                 a2_y+=a2_step_y;
1640         }
1641         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1642         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1643         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1644 }
1645 #endif
1646 #ifndef blitter_code_0x308000a4
1647 #define blitter_code_0x308000a4
1648 void blitter_0x308000a4(void)
1649 {
1650         while (outer_loop--)
1651         {
1652                 inner_loop=n_pixels;
1653                 while (inner_loop--)
1654                 {
1655                         uint32 srcdata   = 0;
1656                         uint32 srczdata  = 0;
1657                         uint32 dstdata   = 0;
1658                         uint32 dstzdata  = 0;
1659                         uint32 writedata = 0;
1660                         uint32 inhibit   = 0;
1661                         srcdata = READ_PIXEL_16(a2);
1662                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
1663                                 writedata |= srcdata  & dstdata;
1664                         WRITE_PIXEL_16(a1, writedata);
1665                         a1_x += a1_xadd;
1666                         a1_y += a1_yadd;
1667                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1668                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1669                 }
1670                 a1_x+=a1_step_x;
1671                 a1_y+=a1_step_y;
1672                 a2_x+=a2_step_x;
1673                 a2_y+=a2_step_y;
1674         }
1675         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1676         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1677         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1678 }
1679 #endif
1680 #ifndef blitter_code_0x14010024
1681 #define blitter_code_0x14010024
1682 void blitter_0x14010024(void)
1683 {
1684         while (outer_loop--)
1685         {
1686                 inner_loop=n_pixels;
1687                 while (inner_loop--)
1688                 {
1689                         uint32 srcdata   = 0;
1690                         uint32 srczdata  = 0;
1691                         uint32 dstdata   = 0;
1692                         uint32 dstzdata  = 0;
1693                         uint32 writedata = 0;
1694                         uint32 inhibit   = 0;
1695                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
1696                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
1697                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
1698                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
1699                         WRITE_PIXEL_16(a1, writedata);
1700                         a1_x += a1_xadd;
1701                         a1_y += a1_yadd;
1702                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1703                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1704                 }
1705                 a1_x+=a1_step_x;
1706                 a1_y+=a1_step_y;
1707                 a2_x+=a2_step_x;
1708                 a2_y+=a2_step_y;
1709         }
1710         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1711         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1712         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1713 }
1714 #endif
1715 #ifndef blitter_code_0x14010023
1716 #define blitter_code_0x14010023
1717 void blitter_0x14010023(void)
1718 {
1719         while (outer_loop--)
1720         {
1721                 inner_loop=n_pixels;
1722                 while (inner_loop--)
1723                 {
1724                         uint32 srcdata   = 0;
1725                         uint32 srczdata  = 0;
1726                         uint32 dstdata   = 0;
1727                         uint32 dstzdata  = 0;
1728                         uint32 writedata = 0;
1729                         uint32 inhibit   = 0;
1730                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
1731                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
1732                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
1733                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
1734                         WRITE_PIXEL_8(a1, writedata);
1735                         a1_x += a1_xadd;
1736                         a1_y += a1_yadd;
1737                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1738                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1739                 }
1740                 a1_x+=a1_step_x;
1741                 a1_y+=a1_step_y;
1742                 a2_x+=a2_step_x;
1743                 a2_y+=a2_step_y;
1744         }
1745         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1746         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1747         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1748 }
1749 #endif
1750 #ifndef blitter_code_0x30e000a4
1751 #define blitter_code_0x30e000a4
1752 void blitter_0x30e000a4(void)
1753 {
1754         while (outer_loop--)
1755         {
1756                 inner_loop=n_pixels;
1757                 while (inner_loop--)
1758                 {
1759                         uint32 srcdata   = 0;
1760                         uint32 srczdata  = 0;
1761                         uint32 dstdata   = 0;
1762                         uint32 dstzdata  = 0;
1763                         uint32 writedata = 0;
1764                         uint32 inhibit   = 0;
1765                         srcdata = READ_PIXEL_16(a2);
1766                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
1767                                 writedata |= ~srcdata & dstdata;
1768                                 writedata |= srcdata  & ~dstdata;
1769                                 writedata |= srcdata  & dstdata;
1770                         WRITE_PIXEL_16(a1, writedata);
1771                         a1_x += a1_xadd;
1772                         a1_y += a1_yadd;
1773                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1774                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1775                 }
1776                 a1_x+=a1_step_x;
1777                 a1_y+=a1_step_y;
1778                 a2_x+=a2_step_x;
1779                 a2_y+=a2_step_y;
1780         }
1781         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1782         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1783         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1784 }
1785 #endif
1786 #ifndef blitter_code_0x10000013
1787 #define blitter_code_0x10000013
1788 void blitter_0x10000013(void)
1789 {
1790         while (outer_loop--)
1791         {
1792                 inner_loop=n_pixels;
1793                 while (inner_loop--)
1794                 {
1795                         uint32 srcdata   = 0;
1796                         uint32 srczdata  = 0;
1797                         uint32 dstdata   = 0;
1798                         uint32 dstzdata  = 0;
1799                         uint32 writedata = 0;
1800                         uint32 inhibit   = 0;
1801                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
1802                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
1803                         WRITE_PIXEL_8(a1, writedata);
1804                         a1_x += a1_xadd;
1805                         a1_y += a1_yadd;
1806                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1807                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1808                 }
1809                 a1_x+=a1_step_x;
1810                 a1_y+=a1_step_y;
1811                 a2_x+=a2_step_x;
1812                 a2_y+=a2_step_y;
1813         }
1814         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1815         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1816         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1817 }
1818 #endif
1819 #ifndef blitter_code_0x00c00292
1820 #define blitter_code_0x00c00292
1821 void blitter_0x00c00292(void)
1822 {
1823         while (outer_loop--)
1824         {
1825                 inner_loop=n_pixels;
1826                 while (inner_loop--)
1827                 {
1828                         uint32 srcdata   = 0;
1829                         uint32 srczdata  = 0;
1830                         uint32 dstdata   = 0;
1831                         uint32 dstzdata  = 0;
1832                         uint32 writedata = 0;
1833                         uint32 inhibit   = 0;
1834                         srcdata = READ_PIXEL_4(a2);
1835                         dstdata = READ_PIXEL_4(a1);
1836                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
1837                                 writedata |= srcdata  & ~dstdata;
1838                                 writedata |= srcdata  & dstdata;
1839                                 WRITE_PIXEL_4(a1, writedata);
1840                         a1_x += a1_xadd;
1841                         a1_y += a1_yadd;
1842                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1843                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1844                 }
1845                 a1_x+=a1_step_x;
1846                 a1_y+=a1_step_y;
1847                 a2_x+=a2_step_x;
1848                 a2_y+=a2_step_y;
1849         }
1850         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1851         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1852         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1853 }
1854 #endif
1855 #ifndef blitter_code_0x008000a4
1856 #define blitter_code_0x008000a4
1857 void blitter_0x008000a4(void)
1858 {
1859         while (outer_loop--)
1860         {
1861                 inner_loop=n_pixels;
1862                 while (inner_loop--)
1863                 {
1864                         uint32 srcdata   = 0;
1865                         uint32 srczdata  = 0;
1866                         uint32 dstdata   = 0;
1867                         uint32 dstzdata  = 0;
1868                         uint32 writedata = 0;
1869                         uint32 inhibit   = 0;
1870                         srcdata = READ_PIXEL_16(a2);
1871                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
1872                                 writedata |= srcdata  & dstdata;
1873                                 WRITE_PIXEL_16(a1, writedata);
1874                         a1_x += a1_xadd;
1875                         a1_y += a1_yadd;
1876                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1877                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1878                 }
1879                 a1_x+=a1_step_x;
1880                 a1_y+=a1_step_y;
1881                 a2_x+=a2_step_x;
1882                 a2_y+=a2_step_y;
1883         }
1884         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1885         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1886         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1887 }
1888 #endif
1889 #ifndef blitter_code_0x00800092
1890 #define blitter_code_0x00800092
1891 void blitter_0x00800092(void)
1892 {
1893         while (outer_loop--)
1894         {
1895                 inner_loop=n_pixels;
1896                 while (inner_loop--)
1897                 {
1898                         uint32 srcdata   = 0;
1899                         uint32 srczdata  = 0;
1900                         uint32 dstdata   = 0;
1901                         uint32 dstzdata  = 0;
1902                         uint32 writedata = 0;
1903                         uint32 inhibit   = 0;
1904                         srcdata = READ_PIXEL_4(a2);
1905                         dstdata = READ_RDATA_4(DSTDATA, a1, a1_phrase_mode);
1906                                 writedata |= srcdata  & dstdata;
1907                                 WRITE_PIXEL_4(a1, writedata);
1908                         a1_x += a1_xadd;
1909                         a1_y += a1_yadd;
1910                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1911                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1912                 }
1913                 a1_x+=a1_step_x;
1914                 a1_y+=a1_step_y;
1915                 a2_x+=a2_step_x;
1916                 a2_y+=a2_step_y;
1917         }
1918         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1919         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1920         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1921 }
1922 #endif
1923 #ifndef blitter_code_0x2cc10023
1924 #define blitter_code_0x2cc10023
1925 void blitter_0x2cc10023(void)
1926 {
1927         while (outer_loop--)
1928         {
1929                 inner_loop=n_pixels;
1930                 while (inner_loop--)
1931                 {
1932                         uint32 srcdata   = 0;
1933                         uint32 srczdata  = 0;
1934                         uint32 dstdata   = 0;
1935                         uint32 dstzdata  = 0;
1936                         uint32 writedata = 0;
1937                         uint32 inhibit   = 0;
1938                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
1939                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
1940                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
1941                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
1942                         if (!inhibit)
1943                         {
1944                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
1945                         } else { srczdata=dstzdata; writedata=dstdata; }
1946                         if (!inhibit)
1947                         {
1948                                 WRITE_PIXEL_8(a1, writedata);
1949                         }
1950                         a1_x += a1_xadd;
1951                         a1_y += a1_yadd;
1952                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1953                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1954                 }
1955                 a1_x+=a1_step_x;
1956                 a1_y+=a1_step_y;
1957                 a2_x+=a2_step_x;
1958                 a2_y+=a2_step_y;
1959         }
1960         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1961         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
1962         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
1963 }
1964 #endif
1965 #ifndef blitter_code_0x34c10023
1966 #define blitter_code_0x34c10023
1967 void blitter_0x34c10023(void)
1968 {
1969         while (outer_loop--)
1970         {
1971                 inner_loop=n_pixels;
1972                 while (inner_loop--)
1973                 {
1974                         uint32 srcdata   = 0;
1975                         uint32 srczdata  = 0;
1976                         uint32 dstdata   = 0;
1977                         uint32 dstzdata  = 0;
1978                         uint32 writedata = 0;
1979                         uint32 inhibit   = 0;
1980                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
1981                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
1982                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
1983                         if (!inhibit)
1984                         {
1985                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
1986                         } else { srczdata=dstzdata; writedata=dstdata; }
1987                         WRITE_PIXEL_8(a1, writedata);
1988                         a1_x += a1_xadd;
1989                         a1_y += a1_yadd;
1990                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
1991                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
1992                 }
1993                 a1_x+=a1_step_x;
1994                 a1_y+=a1_step_y;
1995                 a2_x+=a2_step_x;
1996                 a2_y+=a2_step_y;
1997         }
1998         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
1999         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2000         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2001 }
2002 #endif
2003 #ifndef blitter_code_0x38c0429b
2004 #define blitter_code_0x38c0429b
2005 void blitter_0x38c0429b(void)
2006 {
2007         while (outer_loop--)
2008         {
2009                 inner_loop=n_pixels;
2010                 while (inner_loop--)
2011                 {
2012                         uint32 srcdata   = 0;
2013                         uint32 srczdata  = 0;
2014                         uint32 dstdata   = 0;
2015                         uint32 dstzdata  = 0;
2016                         uint32 writedata = 0;
2017                         uint32 inhibit   = 0;
2018                         srcdata = READ_PIXEL_8(a2);
2019                         dstdata = READ_PIXEL_8(a1);
2020                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
2021                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2022                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
2023                         if (!inhibit)
2024                         {
2025                                 writedata |= srcdata  & ~dstdata;
2026                                 writedata |= srcdata  & dstdata;
2027                         } else { srczdata=dstzdata; writedata=dstdata; }
2028                         WRITE_PIXEL_8(a1, writedata);
2029                         a1_x += a1_xadd;
2030                         a1_y += a1_yadd;
2031                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2032                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2033                 }
2034                 a1_x+=a1_step_x;
2035                 a1_y+=a1_step_y;
2036                 a2_x+=a2_step_x;
2037                 a2_y+=a2_step_y;
2038         }
2039         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2040         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2041         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2042 }
2043 #endif
2044 #ifndef blitter_code_0x3cc1001b
2045 #define blitter_code_0x3cc1001b
2046 void blitter_0x3cc1001b(void)
2047 {
2048         while (outer_loop--)
2049         {
2050                 inner_loop=n_pixels;
2051                 while (inner_loop--)
2052                 {
2053                         uint32 srcdata   = 0;
2054                         uint32 srczdata  = 0;
2055                         uint32 dstdata   = 0;
2056                         uint32 dstzdata  = 0;
2057                         uint32 writedata = 0;
2058                         uint32 inhibit   = 0;
2059                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
2060                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
2061                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
2062                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2063                         if (!inhibit)
2064                         {
2065                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
2066                         } else { srczdata=dstzdata; writedata=dstdata; }
2067                         WRITE_PIXEL_8(a1, writedata);
2068                         a1_x += a1_xadd;
2069                         a1_y += a1_yadd;
2070                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2071                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2072                 }
2073                 a1_x+=a1_step_x;
2074                 a1_y+=a1_step_y;
2075                 a2_x+=a2_step_x;
2076                 a2_y+=a2_step_y;
2077         }
2078         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2079         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2080         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2081 }
2082 #endif
2083 #ifndef blitter_code_0x2cc1001b
2084 #define blitter_code_0x2cc1001b
2085 void blitter_0x2cc1001b(void)
2086 {
2087         while (outer_loop--)
2088         {
2089                 inner_loop=n_pixels;
2090                 while (inner_loop--)
2091                 {
2092                         uint32 srcdata   = 0;
2093                         uint32 srczdata  = 0;
2094                         uint32 dstdata   = 0;
2095                         uint32 dstzdata  = 0;
2096                         uint32 writedata = 0;
2097                         uint32 inhibit   = 0;
2098                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
2099                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
2100                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
2101                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2102                         if (!inhibit)
2103                         {
2104                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
2105                         } else { srczdata=dstzdata; writedata=dstdata; }
2106                         if (!inhibit)
2107                         {
2108                                 WRITE_PIXEL_8(a1, writedata);
2109                         }
2110                         a1_x += a1_xadd;
2111                         a1_y += a1_yadd;
2112                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2113                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2114                 }
2115                 a1_x+=a1_step_x;
2116                 a1_y+=a1_step_y;
2117                 a2_x+=a2_step_x;
2118                 a2_y+=a2_step_y;
2119         }
2120         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2121         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2122         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2123 }
2124 #endif
2125 #ifndef blitter_code_0x08c0429b
2126 #define blitter_code_0x08c0429b
2127 void blitter_0x08c0429b(void)
2128 {
2129         while (outer_loop--)
2130         {
2131                 inner_loop=n_pixels;
2132                 while (inner_loop--)
2133                 {
2134                         uint32 srcdata   = 0;
2135                         uint32 srczdata  = 0;
2136                         uint32 dstdata   = 0;
2137                         uint32 dstzdata  = 0;
2138                         uint32 writedata = 0;
2139                         uint32 inhibit   = 0;
2140                         srcdata = READ_PIXEL_8(a2);
2141                         dstdata = READ_PIXEL_8(a1);
2142                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
2143                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2144                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
2145                         if (!inhibit)
2146                         {
2147                                 writedata |= srcdata  & ~dstdata;
2148                                 writedata |= srcdata  & dstdata;
2149                         } else { srczdata=dstzdata; writedata=dstdata; }
2150                         if (!inhibit)
2151                         {
2152                                 WRITE_PIXEL_8(a1, writedata);
2153                         }
2154                         a1_x += a1_xadd;
2155                         a1_y += a1_yadd;
2156                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2157                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2158                 }
2159                 a1_x+=a1_step_x;
2160                 a1_y+=a1_step_y;
2161                 a2_x+=a2_step_x;
2162                 a2_y+=a2_step_y;
2163         }
2164         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2165         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2166         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2167 }
2168 #endif
2169 #ifndef blitter_code_0x1cc1001b
2170 #define blitter_code_0x1cc1001b
2171 void blitter_0x1cc1001b(void)
2172 {
2173         while (outer_loop--)
2174         {
2175                 inner_loop=n_pixels;
2176                 while (inner_loop--)
2177                 {
2178                         uint32 srcdata   = 0;
2179                         uint32 srczdata  = 0;
2180                         uint32 dstdata   = 0;
2181                         uint32 dstzdata  = 0;
2182                         uint32 writedata = 0;
2183                         uint32 inhibit   = 0;
2184                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
2185                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
2186                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
2187                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2188                         if (!inhibit)
2189                         {
2190                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
2191                         } else { srczdata=dstzdata; writedata=dstdata; }
2192                         WRITE_PIXEL_8(a1, writedata);
2193                         a1_x += a1_xadd;
2194                         a1_y += a1_yadd;
2195                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2196                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2197                 }
2198                 a1_x+=a1_step_x;
2199                 a1_y+=a1_step_y;
2200                 a2_x+=a2_step_x;
2201                 a2_y+=a2_step_y;
2202         }
2203         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2204         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2205         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2206 }
2207 #endif
2208 #ifndef blitter_code_0x0cc1001b
2209 #define blitter_code_0x0cc1001b
2210 void blitter_0x0cc1001b(void)
2211 {
2212         while (outer_loop--)
2213         {
2214                 inner_loop=n_pixels;
2215                 while (inner_loop--)
2216                 {
2217                         uint32 srcdata   = 0;
2218                         uint32 srczdata  = 0;
2219                         uint32 dstdata   = 0;
2220                         uint32 dstzdata  = 0;
2221                         uint32 writedata = 0;
2222                         uint32 inhibit   = 0;
2223                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
2224                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
2225                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
2226                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2227                         if (!inhibit)
2228                         {
2229                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
2230                         } else { srczdata=dstzdata; writedata=dstdata; }
2231                         if (!inhibit)
2232                         {
2233                                 WRITE_PIXEL_8(a1, writedata);
2234                         }
2235                         a1_x += a1_xadd;
2236                         a1_y += a1_yadd;
2237                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2238                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2239                 }
2240                 a1_x+=a1_step_x;
2241                 a1_y+=a1_step_y;
2242                 a2_x+=a2_step_x;
2243                 a2_y+=a2_step_y;
2244         }
2245         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2246         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2247         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2248 }
2249 #endif
2250 #ifndef blitter_code_0x3cc10023
2251 #define blitter_code_0x3cc10023
2252 void blitter_0x3cc10023(void)
2253 {
2254         while (outer_loop--)
2255         {
2256                 inner_loop=n_pixels;
2257                 while (inner_loop--)
2258                 {
2259                         uint32 srcdata   = 0;
2260                         uint32 srczdata  = 0;
2261                         uint32 dstdata   = 0;
2262                         uint32 dstzdata  = 0;
2263                         uint32 writedata = 0;
2264                         uint32 inhibit   = 0;
2265                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
2266                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
2267                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
2268                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2269                         if (!inhibit)
2270                         {
2271                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
2272                         } else { srczdata=dstzdata; writedata=dstdata; }
2273                         WRITE_PIXEL_8(a1, writedata);
2274                         a1_x += a1_xadd;
2275                         a1_y += a1_yadd;
2276                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2277                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2278                 }
2279                 a1_x+=a1_step_x;
2280                 a1_y+=a1_step_y;
2281                 a2_x+=a2_step_x;
2282                 a2_y+=a2_step_y;
2283         }
2284         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2285         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2286         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2287 }
2288 #endif
2289 #ifndef blitter_code_0x08c0009b
2290 #define blitter_code_0x08c0009b
2291 void blitter_0x08c0009b(void)
2292 {
2293         while (outer_loop--)
2294         {
2295                 inner_loop=n_pixels;
2296                 while (inner_loop--)
2297                 {
2298                         uint32 srcdata   = 0;
2299                         uint32 srczdata  = 0;
2300                         uint32 dstdata   = 0;
2301                         uint32 dstzdata  = 0;
2302                         uint32 writedata = 0;
2303                         uint32 inhibit   = 0;
2304                         srcdata = READ_PIXEL_8(a2);
2305                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
2306                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2307                         if (!inhibit)
2308                         {
2309                                 writedata |= srcdata  & ~dstdata;
2310                                 writedata |= srcdata  & dstdata;
2311                         } else { srczdata=dstzdata; writedata=dstdata; }
2312                         if (!inhibit)
2313                         {
2314                                 WRITE_PIXEL_8(a1, writedata);
2315                         }
2316                         a1_x += a1_xadd;
2317                         a1_y += a1_yadd;
2318                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2319                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2320                 }
2321                 a1_x+=a1_step_x;
2322                 a1_y+=a1_step_y;
2323                 a2_x+=a2_step_x;
2324                 a2_y+=a2_step_y;
2325         }
2326         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2327         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2328         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2329 }
2330 #endif
2331 #ifndef blitter_code_0x28c0429b
2332 #define blitter_code_0x28c0429b
2333 void blitter_0x28c0429b(void)
2334 {
2335         while (outer_loop--)
2336         {
2337                 inner_loop=n_pixels;
2338                 while (inner_loop--)
2339                 {
2340                         uint32 srcdata   = 0;
2341                         uint32 srczdata  = 0;
2342                         uint32 dstdata   = 0;
2343                         uint32 dstzdata  = 0;
2344                         uint32 writedata = 0;
2345                         uint32 inhibit   = 0;
2346                         srcdata = READ_PIXEL_8(a2);
2347                         dstdata = READ_PIXEL_8(a1);
2348                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
2349                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2350                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
2351                         if (!inhibit)
2352                         {
2353                                 writedata |= srcdata  & ~dstdata;
2354                                 writedata |= srcdata  & dstdata;
2355                         } else { srczdata=dstzdata; writedata=dstdata; }
2356                         if (!inhibit)
2357                         {
2358                                 WRITE_PIXEL_8(a1, writedata);
2359                         }
2360                         a1_x += a1_xadd;
2361                         a1_y += a1_yadd;
2362                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2363                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2364                 }
2365                 a1_x+=a1_step_x;
2366                 a1_y+=a1_step_y;
2367                 a2_x+=a2_step_x;
2368                 a2_y+=a2_step_y;
2369         }
2370         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2371         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2372         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2373 }
2374 #endif
2375 #ifndef blitter_code_0x18c0429b
2376 #define blitter_code_0x18c0429b
2377 void blitter_0x18c0429b(void)
2378 {
2379         while (outer_loop--)
2380         {
2381                 inner_loop=n_pixels;
2382                 while (inner_loop--)
2383                 {
2384                         uint32 srcdata   = 0;
2385                         uint32 srczdata  = 0;
2386                         uint32 dstdata   = 0;
2387                         uint32 dstzdata  = 0;
2388                         uint32 writedata = 0;
2389                         uint32 inhibit   = 0;
2390                         srcdata = READ_PIXEL_8(a2);
2391                         dstdata = READ_PIXEL_8(a1);
2392                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
2393                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2394                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
2395                         if (!inhibit)
2396                         {
2397                                 writedata |= srcdata  & ~dstdata;
2398                                 writedata |= srcdata  & dstdata;
2399                         } else { srczdata=dstzdata; writedata=dstdata; }
2400                         WRITE_PIXEL_8(a1, writedata);
2401                         a1_x += a1_xadd;
2402                         a1_y += a1_yadd;
2403                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2404                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2405                 }
2406                 a1_x+=a1_step_x;
2407                 a1_y+=a1_step_y;
2408                 a2_x+=a2_step_x;
2409                 a2_y+=a2_step_y;
2410         }
2411         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2412         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2413         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2414 }
2415 #endif
2416 #ifndef blitter_code_0x34010005
2417 #define blitter_code_0x34010005
2418 void blitter_0x34010005(void)
2419 {
2420         while (outer_loop--)
2421         {
2422                 inner_loop=n_pixels;
2423                 while (inner_loop--)
2424                 {
2425                         uint32 srcdata   = 0;
2426                         uint32 srczdata  = 0;
2427                         uint32 dstdata   = 0;
2428                         uint32 dstzdata  = 0;
2429                         uint32 writedata = 0;
2430                         uint32 inhibit   = 0;
2431                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
2432                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
2433                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
2434                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
2435                         WRITE_PIXEL_32(a1, writedata);
2436                         a1_x += a1_xadd;
2437                         a1_y += a1_yadd;
2438                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2439                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2440                 }
2441                 a1_x+=a1_step_x;
2442                 a1_y+=a1_step_y;
2443                 a2_x+=a2_step_x;
2444                 a2_y+=a2_step_y;
2445         }
2446         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2447         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2448         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2449 }
2450 #endif
2451 #ifndef blitter_code_0x3401002d
2452 #define blitter_code_0x3401002d
2453 void blitter_0x3401002d(void)
2454 {
2455         while (outer_loop--)
2456         {
2457                 inner_loop=n_pixels;
2458                 while (inner_loop--)
2459                 {
2460                         uint32 srcdata   = 0;
2461                         uint32 srczdata  = 0;
2462                         uint32 dstdata   = 0;
2463                         uint32 dstzdata  = 0;
2464                         uint32 writedata = 0;
2465                         uint32 inhibit   = 0;
2466                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
2467                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
2468                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
2469                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
2470                         WRITE_PIXEL_32(a1, writedata);
2471                         a1_x += a1_xadd;
2472                         a1_y += a1_yadd;
2473                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2474                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2475                 }
2476                 a1_x+=a1_step_x;
2477                 a1_y+=a1_step_y;
2478                 a2_x+=a2_step_x;
2479                 a2_y+=a2_step_y;
2480         }
2481         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2482         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2483         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2484 }
2485 #endif
2486 #ifndef blitter_code_0x14010025
2487 #define blitter_code_0x14010025
2488 void blitter_0x14010025(void)
2489 {
2490         while (outer_loop--)
2491         {
2492                 inner_loop=n_pixels;
2493                 while (inner_loop--)
2494                 {
2495                         uint32 srcdata   = 0;
2496                         uint32 srczdata  = 0;
2497                         uint32 dstdata   = 0;
2498                         uint32 dstzdata  = 0;
2499                         uint32 writedata = 0;
2500                         uint32 inhibit   = 0;
2501                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
2502                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
2503                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
2504                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
2505                         WRITE_PIXEL_32(a1, writedata);
2506                         a1_x += a1_xadd;
2507                         a1_y += a1_yadd;
2508                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2509                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2510                 }
2511                 a1_x+=a1_step_x;
2512                 a1_y+=a1_step_y;
2513                 a2_x+=a2_step_x;
2514                 a2_y+=a2_step_y;
2515         }
2516         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2517         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2518         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2519 }
2520 #endif
2521 #ifndef blitter_code_0x34010025
2522 #define blitter_code_0x34010025
2523 void blitter_0x34010025(void)
2524 {
2525         while (outer_loop--)
2526         {
2527                 inner_loop=n_pixels;
2528                 while (inner_loop--)
2529                 {
2530                         uint32 srcdata   = 0;
2531                         uint32 srczdata  = 0;
2532                         uint32 dstdata   = 0;
2533                         uint32 dstzdata  = 0;
2534                         uint32 writedata = 0;
2535                         uint32 inhibit   = 0;
2536                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
2537                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
2538                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
2539                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
2540                         WRITE_PIXEL_32(a1, writedata);
2541                         a1_x += a1_xadd;
2542                         a1_y += a1_yadd;
2543                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2544                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2545                 }
2546                 a1_x+=a1_step_x;
2547                 a1_y+=a1_step_y;
2548                 a2_x+=a2_step_x;
2549                 a2_y+=a2_step_y;
2550         }
2551         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2552         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2553         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2554 }
2555 #endif
2556 #ifndef blitter_code_0x3401006c
2557 #define blitter_code_0x3401006c
2558 void blitter_0x3401006c(void)
2559 {
2560         while (outer_loop--)
2561         {
2562                 inner_loop=n_pixels;
2563                 while (inner_loop--)
2564                 {
2565                         uint32 srcdata   = 0;
2566                         uint32 srczdata  = 0;
2567                         uint32 dstdata   = 0;
2568                         uint32 dstzdata  = 0;
2569                         uint32 writedata = 0;
2570                         uint32 inhibit   = 0;
2571                         srcdata = READ_RDATA_32(SRCDATA, a1, a1_phrase_mode);
2572                         srczdata = READ_RDATA_32(SRCZINT, a1, a1_phrase_mode);
2573                         dstdata = READ_RDATA_32(DSTDATA, a2, a2_phrase_mode);
2574                                 writedata= READ_RDATA_32(PATTERNDATA, a2, a2_phrase_mode);
2575                         WRITE_PIXEL_32(a2, writedata);
2576                         a1_x += a1_xadd;
2577                         a1_y += a1_yadd;
2578                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2579                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2580                 }
2581                 a1_x+=a1_step_x;
2582                 a1_y+=a1_step_y;
2583                 a2_x+=a2_step_x;
2584                 a2_y+=a2_step_y;
2585         }
2586         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2587         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2588         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2589 }
2590 #endif
2591 #ifndef blitter_code_0x2401022a
2592 #define blitter_code_0x2401022a
2593 void blitter_0x2401022a(void)
2594 {
2595         while (outer_loop--)
2596         {
2597                 inner_loop=n_pixels;
2598                 while (inner_loop--)
2599                 {
2600                         uint32 srcdata   = 0;
2601                         uint32 srczdata  = 0;
2602                         uint32 dstdata   = 0;
2603                         uint32 dstzdata  = 0;
2604                         uint32 writedata = 0;
2605                         uint32 inhibit   = 0;
2606                         srcdata = READ_RDATA_4(SRCDATA, a2, a2_phrase_mode);
2607                         srczdata = READ_RDATA_4(SRCZINT, a2, a2_phrase_mode);
2608                         dstdata = READ_PIXEL_4(a1);
2609                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
2610                                 writedata= READ_RDATA_4(PATTERNDATA, a1, a1_phrase_mode);
2611                                 WRITE_PIXEL_4(a1, writedata);
2612                         a1_x += a1_xadd;
2613                         a1_y += a1_yadd;
2614                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2615                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2616                 }
2617                 a1_x+=a1_step_x;
2618                 a1_y+=a1_step_y;
2619                 a2_x+=a2_step_x;
2620                 a2_y+=a2_step_y;
2621         }
2622         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2623         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2624         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2625 }
2626 #endif
2627 #ifndef blitter_code_0x2401006a
2628 #define blitter_code_0x2401006a
2629 void blitter_0x2401006a(void)
2630 {
2631         while (outer_loop--)
2632         {
2633                 inner_loop=n_pixels;
2634                 while (inner_loop--)
2635                 {
2636                         uint32 srcdata   = 0;
2637                         uint32 srczdata  = 0;
2638                         uint32 dstdata   = 0;
2639                         uint32 dstzdata  = 0;
2640                         uint32 writedata = 0;
2641                         uint32 inhibit   = 0;
2642                         srcdata = READ_RDATA_32(SRCDATA, a1, a1_phrase_mode);
2643                         srczdata = READ_RDATA_32(SRCZINT, a1, a1_phrase_mode);
2644                         dstdata = READ_RDATA_32(DSTDATA, a2, a2_phrase_mode);
2645                                 writedata= READ_RDATA_32(PATTERNDATA, a2, a2_phrase_mode);
2646                         WRITE_PIXEL_32(a2, writedata);
2647                         a1_x += a1_xadd;
2648                         a1_y += a1_yadd;
2649                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2650                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2651                 }
2652                 a1_x+=a1_step_x;
2653                 a1_y+=a1_step_y;
2654                 a2_x+=a2_step_x;
2655                 a2_y+=a2_step_y;
2656         }
2657         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2658         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2659         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2660 }
2661 #endif
2662 #ifndef blitter_code_0x00c002e4
2663 #define blitter_code_0x00c002e4
2664 void blitter_0x00c002e4(void)
2665 {
2666         while (outer_loop--)
2667         {
2668                 inner_loop=n_pixels;
2669                 while (inner_loop--)
2670                 {
2671                         uint32 srcdata   = 0;
2672                         uint32 srczdata  = 0;
2673                         uint32 dstdata   = 0;
2674                         uint32 dstzdata  = 0;
2675                         uint32 writedata = 0;
2676                         uint32 inhibit   = 0;
2677                         srcdata = READ_PIXEL_16(a1);
2678                         dstdata = READ_PIXEL_16(a2);
2679                         dstzdata = READ_RDATA_16(DSTZ, a2, a2_phrase_mode);
2680                         srczdata=z_i[colour_index]>>16;
2681                                 writedata |= srcdata  & ~dstdata;
2682                                 writedata |= srcdata  & dstdata;
2683                                 {
2684                                 int intensity = srcdata & 0xFF;
2685                                 int ia = gd_ia >> 16;
2686                                 if(ia & 0x80)
2687                                         ia = 0xFFFFFF00 | ia;
2688                                 intensity += ia;
2689                                 if(intensity < 0)
2690                                         intensity = 0;
2691                                 if(intensity > 0xFF)
2692                                         intensity = 0xFF;
2693                                 writedata = (srcdata & 0xFF00) | intensity;
2694                                 }
2695                                 WRITE_PIXEL_16(a2, writedata);
2696                         a1_x += a1_xadd;
2697                         a1_y += a1_yadd;
2698                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2699                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2700                         z_i[colour_index]+=zadd;
2701                         gd_i[colour_index] += gd_ia;
2702                         gd_c[colour_index] += gd_ca;
2703                 }
2704                 a1_x+=a1_step_x;
2705                 a1_y+=a1_step_y;
2706                 a2_x+=a2_step_x;
2707                 a2_y+=a2_step_y;
2708         }
2709         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2710         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2711         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2712 }
2713 #endif
2714 #ifndef blitter_code_0x04010212
2715 #define blitter_code_0x04010212
2716 void blitter_0x04010212(void)
2717 {
2718         while (outer_loop--)
2719         {
2720                 inner_loop=n_pixels;
2721                 while (inner_loop--)
2722                 {
2723                         uint32 srcdata   = 0;
2724                         uint32 srczdata  = 0;
2725                         uint32 dstdata   = 0;
2726                         uint32 dstzdata  = 0;
2727                         uint32 writedata = 0;
2728                         uint32 inhibit   = 0;
2729                         srcdata = READ_RDATA_4(SRCDATA, a2, a2_phrase_mode);
2730                         srczdata = READ_RDATA_4(SRCZINT, a2, a2_phrase_mode);
2731                         dstdata = READ_PIXEL_4(a1);
2732                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
2733                                 writedata= READ_RDATA_4(PATTERNDATA, a1, a1_phrase_mode);
2734                                 WRITE_PIXEL_4(a1, writedata);
2735                         a1_x += a1_xadd;
2736                         a1_y += a1_yadd;
2737                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2738                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2739                 }
2740                 a1_x+=a1_step_x;
2741                 a1_y+=a1_step_y;
2742                 a2_x+=a2_step_x;
2743                 a2_y+=a2_step_y;
2744         }
2745         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2746         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2747         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2748 }
2749 #endif
2750 #ifndef blitter_code_0x2c010023
2751 #define blitter_code_0x2c010023
2752 void blitter_0x2c010023(void)
2753 {
2754         while (outer_loop--)
2755         {
2756                 inner_loop=n_pixels;
2757                 while (inner_loop--)
2758                 {
2759                         uint32 srcdata   = 0;
2760                         uint32 srczdata  = 0;
2761                         uint32 dstdata   = 0;
2762                         uint32 dstzdata  = 0;
2763                         uint32 writedata = 0;
2764                         uint32 inhibit   = 0;
2765                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
2766                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
2767                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
2768                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2769                         if (!inhibit)
2770                         {
2771                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
2772                         } else { srczdata=dstzdata; writedata=dstdata; }
2773                         if (!inhibit)
2774                         {
2775                                 WRITE_PIXEL_8(a1, writedata);
2776                         }
2777                         a1_x += a1_xadd;
2778                         a1_y += a1_yadd;
2779                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2780                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2781                 }
2782                 a1_x+=a1_step_x;
2783                 a1_y+=a1_step_y;
2784                 a2_x+=a2_step_x;
2785                 a2_y+=a2_step_y;
2786         }
2787         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2788         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2789         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2790 }
2791 #endif
2792 #ifndef blitter_code_0x3c010023
2793 #define blitter_code_0x3c010023
2794 void blitter_0x3c010023(void)
2795 {
2796         while (outer_loop--)
2797         {
2798                 inner_loop=n_pixels;
2799                 while (inner_loop--)
2800                 {
2801                         uint32 srcdata   = 0;
2802                         uint32 srczdata  = 0;
2803                         uint32 dstdata   = 0;
2804                         uint32 dstzdata  = 0;
2805                         uint32 writedata = 0;
2806                         uint32 inhibit   = 0;
2807                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
2808                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
2809                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
2810                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2811                         if (!inhibit)
2812                         {
2813                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
2814                         } else { srczdata=dstzdata; writedata=dstdata; }
2815                         WRITE_PIXEL_8(a1, writedata);
2816                         a1_x += a1_xadd;
2817                         a1_y += a1_yadd;
2818                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2819                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2820                 }
2821                 a1_x+=a1_step_x;
2822                 a1_y+=a1_step_y;
2823                 a2_x+=a2_step_x;
2824                 a2_y+=a2_step_y;
2825         }
2826         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2827         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2828         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2829 }
2830 #endif
2831 #ifndef blitter_code_0x3401006b
2832 #define blitter_code_0x3401006b
2833 void blitter_0x3401006b(void)
2834 {
2835         while (outer_loop--)
2836         {
2837                 inner_loop=n_pixels;
2838                 while (inner_loop--)
2839                 {
2840                         uint32 srcdata   = 0;
2841                         uint32 srczdata  = 0;
2842                         uint32 dstdata   = 0;
2843                         uint32 dstzdata  = 0;
2844                         uint32 writedata = 0;
2845                         uint32 inhibit   = 0;
2846                         srcdata = READ_RDATA_32(SRCDATA, a1, a1_phrase_mode);
2847                         srczdata = READ_RDATA_32(SRCZINT, a1, a1_phrase_mode);
2848                         dstdata = READ_RDATA_32(DSTDATA, a2, a2_phrase_mode);
2849                         if (!inhibit)
2850                         {
2851                                 writedata= READ_RDATA_32(PATTERNDATA, a2, a2_phrase_mode);
2852                         } else { srczdata=dstzdata; writedata=dstdata; }
2853                         WRITE_PIXEL_32(a2, writedata);
2854                         a1_x += a1_xadd;
2855                         a1_y += a1_yadd;
2856                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2857                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2858                 }
2859                 a1_x+=a1_step_x;
2860                 a1_y+=a1_step_y;
2861                 a2_x+=a2_step_x;
2862                 a2_y+=a2_step_y;
2863         }
2864         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2865         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2866         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2867 }
2868 #endif
2869 #ifndef blitter_code_0x00c000ad
2870 #define blitter_code_0x00c000ad
2871 void blitter_0x00c000ad(void)
2872 {
2873         while (outer_loop--)
2874         {
2875                 inner_loop=n_pixels;
2876                 while (inner_loop--)
2877                 {
2878                         uint32 srcdata   = 0;
2879                         uint32 srczdata  = 0;
2880                         uint32 dstdata   = 0;
2881                         uint32 dstzdata  = 0;
2882                         uint32 writedata = 0;
2883                         uint32 inhibit   = 0;
2884                         srcdata = READ_PIXEL_32(a2);
2885                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
2886                                 writedata |= srcdata  & ~dstdata;
2887                                 writedata |= srcdata  & dstdata;
2888                                 WRITE_PIXEL_32(a1, writedata);
2889                         a1_x += a1_xadd;
2890                         a1_y += a1_yadd;
2891                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2892                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2893                 }
2894                 a1_x+=a1_step_x;
2895                 a1_y+=a1_step_y;
2896                 a2_x+=a2_step_x;
2897                 a2_y+=a2_step_y;
2898         }
2899         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2900         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2901         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2902 }
2903 #endif
2904 #ifndef blitter_code_0x00e002ad
2905 #define blitter_code_0x00e002ad
2906 void blitter_0x00e002ad(void)
2907 {
2908         while (outer_loop--)
2909         {
2910                 inner_loop=n_pixels;
2911                 while (inner_loop--)
2912                 {
2913                         uint32 srcdata   = 0;
2914                         uint32 srczdata  = 0;
2915                         uint32 dstdata   = 0;
2916                         uint32 dstzdata  = 0;
2917                         uint32 writedata = 0;
2918                         uint32 inhibit   = 0;
2919                         srcdata = READ_PIXEL_32(a2);
2920                         dstdata = READ_PIXEL_32(a1);
2921                         dstzdata = READ_RDATA_32(DSTZ, a1, a1_phrase_mode);
2922                                 writedata |= ~srcdata & dstdata;
2923                                 writedata |= srcdata  & ~dstdata;
2924                                 writedata |= srcdata  & dstdata;
2925                                 WRITE_PIXEL_32(a1, writedata);
2926                         a1_x += a1_xadd;
2927                         a1_y += a1_yadd;
2928                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2929                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2930                 }
2931                 a1_x+=a1_step_x;
2932                 a1_y+=a1_step_y;
2933                 a2_x+=a2_step_x;
2934                 a2_y+=a2_step_y;
2935         }
2936         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2937         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2938         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2939 }
2940 #endif
2941 #ifndef blitter_code_0x08c040a4
2942 #define blitter_code_0x08c040a4
2943 void blitter_0x08c040a4(void)
2944 {
2945         while (outer_loop--)
2946         {
2947                 inner_loop=n_pixels;
2948                 while (inner_loop--)
2949                 {
2950                         uint32 srcdata   = 0;
2951                         uint32 srczdata  = 0;
2952                         uint32 dstdata   = 0;
2953                         uint32 dstzdata  = 0;
2954                         uint32 writedata = 0;
2955                         uint32 inhibit   = 0;
2956                         srcdata = READ_PIXEL_16(a2);
2957                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
2958                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
2959                         if (srcdata == READ_RDATA_16(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
2960                         if (!inhibit)
2961                         {
2962                                 writedata |= srcdata  & ~dstdata;
2963                                 writedata |= srcdata  & dstdata;
2964                         } else { srczdata=dstzdata; writedata=dstdata; }
2965                         if (!inhibit)
2966                         {
2967                                 WRITE_PIXEL_16(a1, writedata);
2968                         }
2969                         a1_x += a1_xadd;
2970                         a1_y += a1_yadd;
2971                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
2972                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
2973                 }
2974                 a1_x+=a1_step_x;
2975                 a1_y+=a1_step_y;
2976                 a2_x+=a2_step_x;
2977                 a2_y+=a2_step_y;
2978         }
2979         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
2980         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
2981         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
2982 }
2983 #endif
2984 #ifndef blitter_code_0x08c000e4
2985 #define blitter_code_0x08c000e4
2986 void blitter_0x08c000e4(void)
2987 {
2988         while (outer_loop--)
2989         {
2990                 inner_loop=n_pixels;
2991                 while (inner_loop--)
2992                 {
2993                         uint32 srcdata   = 0;
2994                         uint32 srczdata  = 0;
2995                         uint32 dstdata   = 0;
2996                         uint32 dstzdata  = 0;
2997                         uint32 writedata = 0;
2998                         uint32 inhibit   = 0;
2999                         srcdata = READ_PIXEL_16(a1);
3000                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
3001                         srczdata=z_i[colour_index]>>16;
3002                         if (!inhibit)
3003                         {
3004                                 writedata |= srcdata  & ~dstdata;
3005                                 writedata |= srcdata  & dstdata;
3006                                 {
3007                                 int intensity = srcdata & 0xFF;
3008                                 int ia = gd_ia >> 16;
3009                                 if(ia & 0x80)
3010                                         ia = 0xFFFFFF00 | ia;
3011                                 intensity += ia;
3012                                 if(intensity < 0)
3013                                         intensity = 0;
3014                                 if(intensity > 0xFF)
3015                                         intensity = 0xFF;
3016                                 writedata = (srcdata & 0xFF00) | intensity;
3017                                 }
3018                         } else { srczdata=dstzdata; writedata=dstdata; }
3019                         if (!inhibit)
3020                         {
3021                                 WRITE_PIXEL_16(a2, writedata);
3022                         }
3023                         a1_x += a1_xadd;
3024                         a1_y += a1_yadd;
3025                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3026                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3027                         z_i[colour_index]+=zadd;
3028                         gd_i[colour_index] += gd_ia;
3029                         gd_c[colour_index] += gd_ca;
3030                 }
3031                 a1_x+=a1_step_x;
3032                 a1_y+=a1_step_y;
3033                 a2_x+=a2_step_x;
3034                 a2_y+=a2_step_y;
3035         }
3036         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3037         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3038         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3039 }
3040 #endif
3041 #ifndef blitter_code_0x2c010024
3042 #define blitter_code_0x2c010024
3043 void blitter_0x2c010024(void)
3044 {
3045         while (outer_loop--)
3046         {
3047                 inner_loop=n_pixels;
3048                 while (inner_loop--)
3049                 {
3050                         uint32 srcdata   = 0;
3051                         uint32 srczdata  = 0;
3052                         uint32 dstdata   = 0;
3053                         uint32 dstzdata  = 0;
3054                         uint32 writedata = 0;
3055                         uint32 inhibit   = 0;
3056                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
3057                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
3058                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
3059                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
3060                         if (!inhibit)
3061                         {
3062                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
3063                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
3064                         } else { srczdata=dstzdata; writedata=dstdata; }
3065                         if (!inhibit)
3066                         {
3067                                 WRITE_PIXEL_16(a1, writedata);
3068                         }
3069                         a1_x += a1_xadd;
3070                         a1_y += a1_yadd;
3071                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3072                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3073                         gd_i[colour_index] += gd_ia;
3074                         gd_c[colour_index] += gd_ca;
3075                 }
3076                 a1_x+=a1_step_x;
3077                 a1_y+=a1_step_y;
3078                 a2_x+=a2_step_x;
3079                 a2_y+=a2_step_y;
3080         }
3081         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3082         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3083         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3084 }
3085 #endif
3086 #ifndef blitter_code_0x3c010024
3087 #define blitter_code_0x3c010024
3088 void blitter_0x3c010024(void)
3089 {
3090         while (outer_loop--)
3091         {
3092                 inner_loop=n_pixels;
3093                 while (inner_loop--)
3094                 {
3095                         uint32 srcdata   = 0;
3096                         uint32 srczdata  = 0;
3097                         uint32 dstdata   = 0;
3098                         uint32 dstzdata  = 0;
3099                         uint32 writedata = 0;
3100                         uint32 inhibit   = 0;
3101                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
3102                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
3103                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
3104                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
3105                         if (!inhibit)
3106                         {
3107                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
3108                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
3109                         } else { srczdata=dstzdata; writedata=dstdata; }
3110                         WRITE_PIXEL_16(a1, writedata);
3111                         a1_x += a1_xadd;
3112                         a1_y += a1_yadd;
3113                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3114                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3115                         gd_i[colour_index] += gd_ia;
3116                         gd_c[colour_index] += gd_ca;
3117                          colour_index=(colour_index+1)&0x3;
3118                 }
3119                 a1_x+=a1_step_x;
3120                 a1_y+=a1_step_y;
3121                 a2_x+=a2_step_x;
3122                 a2_y+=a2_step_y;
3123         }
3124         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3125         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3126         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3127 }
3128 #endif
3129 #ifndef blitter_code_0x0c010024
3130 #define blitter_code_0x0c010024
3131 void blitter_0x0c010024(void)
3132 {
3133         while (outer_loop--)
3134         {
3135                 inner_loop=n_pixels;
3136                 while (inner_loop--)
3137                 {
3138                         uint32 srcdata   = 0;
3139                         uint32 srczdata  = 0;
3140                         uint32 dstdata   = 0;
3141                         uint32 dstzdata  = 0;
3142                         uint32 writedata = 0;
3143                         uint32 inhibit   = 0;
3144                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
3145                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
3146                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
3147                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
3148                         if (!inhibit)
3149                         {
3150                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
3151                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
3152                         } else { srczdata=dstzdata; writedata=dstdata; }
3153                         if (!inhibit)
3154                         {
3155                                 WRITE_PIXEL_16(a1, writedata);
3156                         }
3157                         a1_x += a1_xadd;
3158                         a1_y += a1_yadd;
3159                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3160                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3161                         gd_i[colour_index] += gd_ia;
3162                         gd_c[colour_index] += gd_ca;
3163                 }
3164                 a1_x+=a1_step_x;
3165                 a1_y+=a1_step_y;
3166                 a2_x+=a2_step_x;
3167                 a2_y+=a2_step_y;
3168         }
3169         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3170         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3171         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3172 }
3173 #endif
3174 #ifndef blitter_code_0x1401001d
3175 #define blitter_code_0x1401001d
3176 void blitter_0x1401001d(void)
3177 {
3178         while (outer_loop--)
3179         {
3180                 inner_loop=n_pixels;
3181                 while (inner_loop--)
3182                 {
3183                         uint32 srcdata   = 0;
3184                         uint32 srczdata  = 0;
3185                         uint32 dstdata   = 0;
3186                         uint32 dstzdata  = 0;
3187                         uint32 writedata = 0;
3188                         uint32 inhibit   = 0;
3189                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
3190                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
3191                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
3192                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
3193                         WRITE_PIXEL_32(a1, writedata);
3194                         a1_x += a1_xadd;
3195                         a1_y += a1_yadd;
3196                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3197                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3198                 }
3199                 a1_x+=a1_step_x;
3200                 a1_y+=a1_step_y;
3201                 a2_x+=a2_step_x;
3202                 a2_y+=a2_step_y;
3203         }
3204         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3205         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3206         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3207 }
3208 #endif
3209 #ifndef blitter_code_0x34c10003
3210 #define blitter_code_0x34c10003
3211 void blitter_0x34c10003(void)
3212 {
3213         while (outer_loop--)
3214         {
3215                 inner_loop=n_pixels;
3216                 while (inner_loop--)
3217                 {
3218                         uint32 srcdata   = 0;
3219                         uint32 srczdata  = 0;
3220                         uint32 dstdata   = 0;
3221                         uint32 dstzdata  = 0;
3222                         uint32 writedata = 0;
3223                         uint32 inhibit   = 0;
3224                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
3225                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
3226                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
3227                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
3228                         WRITE_PIXEL_8(a1, writedata);
3229                         a1_x += a1_xadd;
3230                         a1_y += a1_yadd;
3231                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3232                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3233                 }
3234                 a1_x+=a1_step_x;
3235                 a1_y+=a1_step_y;
3236                 a2_x+=a2_step_x;
3237                 a2_y+=a2_step_y;
3238         }
3239         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3240         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3241         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3242 }
3243 #endif
3244 #ifndef blitter_code_0x306002a4
3245 #define blitter_code_0x306002a4
3246 void blitter_0x306002a4(void)
3247 {
3248         while (outer_loop--)
3249         {
3250                 inner_loop=n_pixels;
3251                 while (inner_loop--)
3252                 {
3253                         uint32 srcdata   = 0;
3254                         uint32 srczdata  = 0;
3255                         uint32 dstdata   = 0;
3256                         uint32 dstzdata  = 0;
3257                         uint32 writedata = 0;
3258                         uint32 inhibit   = 0;
3259                         srcdata = READ_PIXEL_16(a2);
3260                         dstdata = READ_PIXEL_16(a1);
3261                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
3262                                 writedata |= ~srcdata & dstdata;
3263                                 writedata |= srcdata  & ~dstdata;
3264                         WRITE_PIXEL_16(a1, writedata);
3265                         a1_x += a1_xadd;
3266                         a1_y += a1_yadd;
3267                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3268                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3269                 }
3270                 a1_x+=a1_step_x;
3271                 a1_y+=a1_step_y;
3272                 a2_x+=a2_step_x;
3273                 a2_y+=a2_step_y;
3274         }
3275         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3276         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3277         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3278 }
3279 #endif
3280 #ifndef blitter_code_0x08c00292
3281 #define blitter_code_0x08c00292
3282 void blitter_0x08c00292(void)
3283 {
3284         while (outer_loop--)
3285         {
3286                 inner_loop=n_pixels;
3287                 while (inner_loop--)
3288                 {
3289                         uint32 srcdata   = 0;
3290                         uint32 srczdata  = 0;
3291                         uint32 dstdata   = 0;
3292                         uint32 dstzdata  = 0;
3293                         uint32 writedata = 0;
3294                         uint32 inhibit   = 0;
3295                         srcdata = READ_PIXEL_4(a2);
3296                         dstdata = READ_PIXEL_4(a1);
3297                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
3298                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
3299                         if (!inhibit)
3300                         {
3301                                 writedata |= srcdata  & ~dstdata;
3302                                 writedata |= srcdata  & dstdata;
3303                         } else { srczdata=dstzdata; writedata=dstdata; }
3304                         if (!inhibit)
3305                         {
3306                                 WRITE_PIXEL_4(a1, writedata);
3307                         }
3308                         a1_x += a1_xadd;
3309                         a1_y += a1_yadd;
3310                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3311                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3312                 }
3313                 a1_x+=a1_step_x;
3314                 a1_y+=a1_step_y;
3315                 a2_x+=a2_step_x;
3316                 a2_y+=a2_step_y;
3317         }
3318         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3319         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3320         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3321 }
3322 #endif
3323 #ifndef blitter_code_0x14c10013
3324 #define blitter_code_0x14c10013
3325 void blitter_0x14c10013(void)
3326 {
3327         while (outer_loop--)
3328         {
3329                 inner_loop=n_pixels;
3330                 while (inner_loop--)
3331                 {
3332                         uint32 srcdata   = 0;
3333                         uint32 srczdata  = 0;
3334                         uint32 dstdata   = 0;
3335                         uint32 dstzdata  = 0;
3336                         uint32 writedata = 0;
3337                         uint32 inhibit   = 0;
3338                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
3339                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
3340                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
3341                         if (!inhibit)
3342                         {
3343                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
3344                         } else { srczdata=dstzdata; writedata=dstdata; }
3345                         WRITE_PIXEL_8(a1, writedata);
3346                         a1_x += a1_xadd;
3347                         a1_y += a1_yadd;
3348                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3349                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3350                 }
3351                 a1_x+=a1_step_x;
3352                 a1_y+=a1_step_y;
3353                 a2_x+=a2_step_x;
3354                 a2_y+=a2_step_y;
3355         }
3356         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3357         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3358         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3359 }
3360 #endif
3361 #ifndef blitter_code_0x38c0009b
3362 #define blitter_code_0x38c0009b
3363 void blitter_0x38c0009b(void)
3364 {
3365         while (outer_loop--)
3366         {
3367                 inner_loop=n_pixels;
3368                 while (inner_loop--)
3369                 {
3370                         uint32 srcdata   = 0;
3371                         uint32 srczdata  = 0;
3372                         uint32 dstdata   = 0;
3373                         uint32 dstzdata  = 0;
3374                         uint32 writedata = 0;
3375                         uint32 inhibit   = 0;
3376                         srcdata = READ_PIXEL_8(a2);
3377                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
3378                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
3379                         if (!inhibit)
3380                         {
3381                                 writedata |= srcdata  & ~dstdata;
3382                                 writedata |= srcdata  & dstdata;
3383                         } else { srczdata=dstzdata; writedata=dstdata; }
3384                         WRITE_PIXEL_8(a1, writedata);
3385                         a1_x += a1_xadd;
3386                         a1_y += a1_yadd;
3387                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3388                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3389                 }
3390                 a1_x+=a1_step_x;
3391                 a1_y+=a1_step_y;
3392                 a2_x+=a2_step_x;
3393                 a2_y+=a2_step_y;
3394         }
3395         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3396         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3397         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3398 }
3399 #endif
3400 #ifndef blitter_code_0x34c1001b
3401 #define blitter_code_0x34c1001b
3402 void blitter_0x34c1001b(void)
3403 {
3404         while (outer_loop--)
3405         {
3406                 inner_loop=n_pixels;
3407                 while (inner_loop--)
3408                 {
3409                         uint32 srcdata   = 0;
3410                         uint32 srczdata  = 0;
3411                         uint32 dstdata   = 0;
3412                         uint32 dstzdata  = 0;
3413                         uint32 writedata = 0;
3414                         uint32 inhibit   = 0;
3415                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
3416                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
3417                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
3418                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
3419                         WRITE_PIXEL_8(a1, writedata);
3420                         a1_x += a1_xadd;
3421                         a1_y += a1_yadd;
3422                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3423                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3424                 }
3425                 a1_x+=a1_step_x;
3426                 a1_y+=a1_step_y;
3427                 a2_x+=a2_step_x;
3428                 a2_y+=a2_step_y;
3429         }
3430         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3431         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3432         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3433 }
3434 #endif
3435 #ifndef blitter_code_0x1401001c
3436 #define blitter_code_0x1401001c
3437 void blitter_0x1401001c(void)
3438 {
3439         while (outer_loop--)
3440         {
3441                 inner_loop=n_pixels;
3442                 while (inner_loop--)
3443                 {
3444                         uint32 srcdata   = 0;
3445                         uint32 srczdata  = 0;
3446                         uint32 dstdata   = 0;
3447                         uint32 dstzdata  = 0;
3448                         uint32 writedata = 0;
3449                         uint32 inhibit   = 0;
3450                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
3451                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
3452                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
3453                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
3454                         WRITE_PIXEL_16(a1, writedata);
3455                         a1_x += a1_xadd;
3456                         a1_y += a1_yadd;
3457                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3458                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3459                 }
3460                 a1_x+=a1_step_x;
3461                 a1_y+=a1_step_y;
3462                 a2_x+=a2_step_x;
3463                 a2_y+=a2_step_y;
3464         }
3465         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3466         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3467         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3468 }
3469 #endif
3470 #ifndef blitter_code_0x08c000db
3471 #define blitter_code_0x08c000db
3472 void blitter_0x08c000db(void)
3473 {
3474         while (outer_loop--)
3475         {
3476                 inner_loop=n_pixels;
3477                 while (inner_loop--)
3478                 {
3479                         uint32 srcdata   = 0;
3480                         uint32 dstdata   = 0;
3481                         uint32 writedata = 0;
3482                         srcdata = READ_PIXEL_8(a1);
3483                         dstdata = READ_RDATA_8(DSTDATA, a2, a2_phrase_mode);
3484                         writedata |= srcdata  & ~dstdata;
3485                         writedata |= srcdata  & dstdata;
3486                         WRITE_PIXEL_8(a2, writedata);
3487                         a1_x += a1_xadd;
3488                         a1_y += a1_yadd;
3489                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3490                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3491                 }
3492                 a1_x+=a1_step_x;
3493                 a1_y+=a1_step_y;
3494                 a2_x+=a2_step_x;
3495                 a2_y+=a2_step_y;
3496         }
3497         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3498         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3499         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3500 }
3501 #endif
3502 #ifndef blitter_code_0x0401001b
3503 #define blitter_code_0x0401001b
3504 void blitter_0x0401001b(void)
3505 {
3506         while (outer_loop--)
3507         {
3508                 inner_loop=n_pixels;
3509                 while (inner_loop--)
3510                 {
3511                         uint32 srcdata   = 0;
3512                         uint32 srczdata  = 0;
3513                         uint32 dstdata   = 0;
3514                         uint32 dstzdata  = 0;
3515                         uint32 writedata = 0;
3516                         uint32 inhibit   = 0;
3517                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
3518                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
3519                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
3520                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
3521                                 WRITE_PIXEL_8(a1, writedata);
3522                         a1_x += a1_xadd;
3523                         a1_y += a1_yadd;
3524                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3525                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3526                 }
3527                 a1_x+=a1_step_x;
3528                 a1_y+=a1_step_y;
3529                 a2_x+=a2_step_x;
3530                 a2_y+=a2_step_y;
3531         }
3532         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3533         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3534         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3535 }
3536 #endif
3537 #ifndef blitter_code_0x0401001d
3538 #define blitter_code_0x0401001d
3539 void blitter_0x0401001d(void)
3540 {
3541         while (outer_loop--)
3542         {
3543                 inner_loop=n_pixels;
3544                 while (inner_loop--)
3545                 {
3546                         uint32 srcdata   = 0;
3547                         uint32 srczdata  = 0;
3548                         uint32 dstdata   = 0;
3549                         uint32 dstzdata  = 0;
3550                         uint32 writedata = 0;
3551                         uint32 inhibit   = 0;
3552                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
3553                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
3554                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
3555                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
3556                                 WRITE_PIXEL_32(a1, writedata);
3557                         a1_x += a1_xadd;
3558                         a1_y += a1_yadd;
3559                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3560                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3561                 }
3562                 a1_x+=a1_step_x;
3563                 a1_y+=a1_step_y;
3564                 a2_x+=a2_step_x;
3565                 a2_y+=a2_step_y;
3566         }
3567         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3568         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3569         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3570 }
3571 #endif
3572 #ifndef blitter_code_0x0401001c
3573 #define blitter_code_0x0401001c
3574 void blitter_0x0401001c(void)
3575 {
3576         while (outer_loop--)
3577         {
3578                 inner_loop=n_pixels;
3579                 while (inner_loop--)
3580                 {
3581                         uint32 srcdata   = 0;
3582                         uint32 srczdata  = 0;
3583                         uint32 dstdata   = 0;
3584                         uint32 dstzdata  = 0;
3585                         uint32 writedata = 0;
3586                         uint32 inhibit   = 0;
3587                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
3588                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
3589                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
3590                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
3591                                 WRITE_PIXEL_16(a1, writedata);
3592                         a1_x += a1_xadd;
3593                         a1_y += a1_yadd;
3594                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3595                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3596                 }
3597                 a1_x+=a1_step_x;
3598                 a1_y+=a1_step_y;
3599                 a2_x+=a2_step_x;
3600                 a2_y+=a2_step_y;
3601         }
3602         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3603         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3604         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3605 }
3606 #endif
3607 #ifndef blitter_code_0x36013624
3608 #define blitter_code_0x36013624
3609 void blitter_0x36013624(void)
3610 {
3611         while (outer_loop--)
3612         {
3613                 inner_loop=n_pixels;
3614                 while (inner_loop--)
3615                 {
3616                         uint32 srcdata   = 0;
3617                         uint32 srczdata  = 0;
3618                         uint32 dstdata   = 0;
3619                         uint32 dstzdata  = 0;
3620                         uint32 writedata = 0;
3621                         uint32 inhibit   = 0;
3622                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
3623                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
3624                         dstdata = READ_PIXEL_16(a1);
3625                         dstzdata = READ_ZDATA_16(a1);
3626                         srczdata=z_i[colour_index]>>16;
3627                         if (srczdata == dstzdata)       inhibit = 1;
3628                         if (srczdata >  dstzdata)       inhibit = 1;
3629                         if (!inhibit)
3630                         {
3631                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
3632                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
3633                         } else { srczdata=dstzdata; writedata=dstdata; }
3634                         WRITE_PIXEL_16(a1, writedata);
3635                         WRITE_ZDATA_16(a1, srczdata);
3636                         a1_x += a1_xadd;
3637                         a1_y += a1_yadd;
3638                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3639                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3640                         z_i[colour_index]+=zadd;
3641                         gd_i[colour_index] += gd_ia;
3642                         gd_c[colour_index] += gd_ca;
3643                          colour_index=(colour_index+1)&0x3;
3644                 }
3645                 a1_x+=a1_step_x;
3646                 a1_y+=a1_step_y;
3647                 a2_x+=a2_step_x;
3648                 a2_y+=a2_step_y;
3649         }
3650         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3651         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3652         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3653 }
3654 #endif
3655 #ifndef blitter_code_0x04c10284
3656 #define blitter_code_0x04c10284
3657 void blitter_0x04c10284(void)
3658 {
3659         while (outer_loop--)
3660         {
3661                 inner_loop=n_pixels;
3662                 while (inner_loop--)
3663                 {
3664                         uint32 srcdata   = 0;
3665                         uint32 srczdata  = 0;
3666                         uint32 dstdata   = 0;
3667                         uint32 dstzdata  = 0;
3668                         uint32 writedata = 0;
3669                         uint32 inhibit   = 0;
3670                         srcdata = READ_PIXEL_16(a2);
3671                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
3672                         dstdata = READ_PIXEL_16(a1);
3673                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
3674                         if (!inhibit)
3675                         {
3676                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
3677                         } else { srczdata=dstzdata; writedata=dstdata; }
3678                         if (!inhibit)
3679                         {
3680                                 WRITE_PIXEL_16(a1, writedata);
3681                         }
3682                         a1_x += a1_xadd;
3683                         a1_y += a1_yadd;
3684                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3685                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3686                 }
3687                 a1_x+=a1_step_x;
3688                 a1_y+=a1_step_y;
3689                 a2_x+=a2_step_x;
3690                 a2_y+=a2_step_y;
3691         }
3692         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3693         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3694         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3695 }
3696 #endif
3697 #ifndef blitter_code_0x14010004
3698 #define blitter_code_0x14010004
3699 void blitter_0x14010004(void)
3700 {
3701         while (outer_loop--)
3702         {
3703                 inner_loop=n_pixels;
3704                 while (inner_loop--)
3705                 {
3706                         uint32 srcdata   = 0;
3707                         uint32 srczdata  = 0;
3708                         uint32 dstdata   = 0;
3709                         uint32 dstzdata  = 0;
3710                         uint32 writedata = 0;
3711                         uint32 inhibit   = 0;
3712                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
3713                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
3714                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
3715                         if (!inhibit)
3716                         {
3717                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
3718                         } else { srczdata=dstzdata; writedata=dstdata; }
3719                         WRITE_PIXEL_16(a1, writedata);
3720                         a1_x += a1_xadd;
3721                         a1_y += a1_yadd;
3722                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3723                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3724                 }
3725                 a1_x+=a1_step_x;
3726                 a1_y+=a1_step_y;
3727                 a2_x+=a2_step_x;
3728                 a2_y+=a2_step_y;
3729         }
3730         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3731         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3732         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3733 }
3734 #endif
3735 #ifndef blitter_code_0x06c076e4
3736 #define blitter_code_0x06c076e4
3737 void blitter_0x06c076e4(void)
3738 {
3739         while (outer_loop--)
3740         {
3741                 inner_loop=n_pixels;
3742                 while (inner_loop--)
3743                 {
3744                         uint32 srcdata   = 0;
3745                         uint32 srczdata  = 0;
3746                         uint32 dstdata   = 0;
3747                         uint32 dstzdata  = 0;
3748                         uint32 writedata = 0;
3749                         uint32 inhibit   = 0;
3750                         srcdata = READ_PIXEL_16(a1);
3751                         srczdata = READ_RDATA_16(SRCZINT, a1, a1_phrase_mode);
3752                         dstdata = READ_PIXEL_16(a2);
3753                         dstzdata = READ_ZDATA_16(a2);
3754                         srczdata=z_i[colour_index]>>16;
3755                         if (srczdata == dstzdata)       inhibit = 1;
3756                         if (srczdata >  dstzdata)       inhibit = 1;
3757                         if (srcdata == READ_RDATA_16(PATTERNDATA, a1,a1_phrase_mode)) inhibit=1;
3758                         if (!inhibit)
3759                         {
3760                                 writedata |= srcdata  & ~dstdata;
3761                                 writedata |= srcdata  & dstdata;
3762                         } else { srczdata=dstzdata; writedata=dstdata; }
3763                         if (!inhibit)
3764                         {
3765                                 WRITE_PIXEL_16(a2, writedata);
3766                                 WRITE_ZDATA_16(a2, srczdata);
3767                         }
3768                         a1_x += a1_xadd;
3769                         a1_y += a1_yadd;
3770                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3771                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3772                         z_i[colour_index]+=zadd;
3773                 }
3774                 a1_x+=a1_step_x;
3775                 a1_y+=a1_step_y;
3776                 a2_x+=a2_step_x;
3777                 a2_y+=a2_step_y;
3778         }
3779         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3780         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3781         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3782 }
3783 #endif
3784 #ifndef blitter_code_0x30c040a4
3785 #define blitter_code_0x30c040a4
3786 void blitter_0x30c040a4(void)
3787 {
3788         while (outer_loop--)
3789         {
3790                 inner_loop=n_pixels;
3791                 while (inner_loop--)
3792                 {
3793                         uint32 srcdata   = 0;
3794                         uint32 srczdata  = 0;
3795                         uint32 dstdata   = 0;
3796                         uint32 dstzdata  = 0;
3797                         uint32 writedata = 0;
3798                         uint32 inhibit   = 0;
3799                         srcdata = READ_PIXEL_16(a2);
3800                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
3801                         srczdata=z_i[colour_index]>>16;
3802                         if (srcdata == READ_RDATA_16(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
3803                         if (!inhibit)
3804                         {
3805                                 writedata |= srcdata  & ~dstdata;
3806                                 writedata |= srcdata  & dstdata;
3807                                 {
3808                                 int intensity = srcdata & 0xFF;
3809                                 int ia = gd_ia >> 16;
3810                                 if(ia & 0x80)
3811                                         ia = 0xFFFFFF00 | ia;
3812                                 intensity += ia;
3813                                 if(intensity < 0)
3814                                         intensity = 0;
3815                                 if(intensity > 0xFF)
3816                                         intensity = 0xFF;
3817                                 writedata = (srcdata & 0xFF00) | intensity;
3818                                 }
3819                         } else { srczdata=dstzdata; writedata=dstdata; }
3820                         WRITE_PIXEL_16(a1, writedata);
3821                         a1_x += a1_xadd;
3822                         a1_y += a1_yadd;
3823                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3824                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3825                         z_i[colour_index]+=zadd;
3826                         gd_i[colour_index] += gd_ia;
3827                         gd_c[colour_index] += gd_ca;
3828                          colour_index=(colour_index+1)&0x3;
3829                 }
3830                 a1_x+=a1_step_x;
3831                 a1_y+=a1_step_y;
3832                 a2_x+=a2_step_x;
3833                 a2_y+=a2_step_y;
3834         }
3835         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3836         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3837         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3838 }
3839 #endif
3840 #ifndef blitter_code_0x00c040db
3841 #define blitter_code_0x00c040db
3842 void blitter_0x00c040db(void)
3843 {
3844         while (outer_loop--)
3845         {
3846                 inner_loop=n_pixels;
3847                 while (inner_loop--)
3848                 {
3849                         uint32 srcdata   = 0;
3850                         uint32 srczdata  = 0;
3851                         uint32 dstdata   = 0;
3852                         uint32 dstzdata  = 0;
3853                         uint32 writedata = 0;
3854                         uint32 inhibit   = 0;
3855                         srcdata = READ_PIXEL_8(a1);
3856                         dstdata = READ_RDATA_8(DSTDATA, a2, a2_phrase_mode);
3857                         if (srcdata == READ_RDATA_8(PATTERNDATA, a1,a1_phrase_mode)) inhibit=1;
3858                         if (!inhibit)
3859                         {
3860                                 writedata |= srcdata  & ~dstdata;
3861                                 writedata |= srcdata  & dstdata;
3862                         } else { srczdata=dstzdata; writedata=dstdata; }
3863                         if (!inhibit)
3864                         {
3865                                 WRITE_PIXEL_8(a2, writedata);
3866                         }
3867                         a1_x += a1_xadd;
3868                         a1_y += a1_yadd;
3869                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3870                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3871                 }
3872                 a1_x+=a1_step_x;
3873                 a1_y+=a1_step_y;
3874                 a2_x+=a2_step_x;
3875                 a2_y+=a2_step_y;
3876         }
3877         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3878         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3879         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3880 }
3881 #endif
3882 #ifndef blitter_code_0x30c0429b
3883 #define blitter_code_0x30c0429b
3884 void blitter_0x30c0429b(void)
3885 {
3886         while (outer_loop--)
3887         {
3888                 inner_loop=n_pixels;
3889                 while (inner_loop--)
3890                 {
3891                         uint32 srcdata   = 0;
3892                         uint32 srczdata  = 0;
3893                         uint32 dstdata   = 0;
3894                         uint32 dstzdata  = 0;
3895                         uint32 writedata = 0;
3896                         uint32 inhibit   = 0;
3897                         srcdata = READ_PIXEL_8(a2);
3898                         dstdata = READ_PIXEL_8(a1);
3899                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
3900                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
3901                         if (!inhibit)
3902                         {
3903                                 writedata |= srcdata  & ~dstdata;
3904                                 writedata |= srcdata  & dstdata;
3905                         } else { srczdata=dstzdata; writedata=dstdata; }
3906                         WRITE_PIXEL_8(a1, writedata);
3907                         a1_x += a1_xadd;
3908                         a1_y += a1_yadd;
3909                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3910                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3911                 }
3912                 a1_x+=a1_step_x;
3913                 a1_y+=a1_step_y;
3914                 a2_x+=a2_step_x;
3915                 a2_y+=a2_step_y;
3916         }
3917         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3918         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3919         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3920 }
3921 #endif
3922 #ifndef blitter_code_0x08c0409b
3923 #define blitter_code_0x08c0409b
3924 void blitter_0x08c0409b(void)
3925 {
3926         while (outer_loop--)
3927         {
3928                 inner_loop=n_pixels;
3929                 while (inner_loop--)
3930                 {
3931                         uint32 srcdata   = 0;
3932                         uint32 srczdata  = 0;
3933                         uint32 dstdata   = 0;
3934                         uint32 dstzdata  = 0;
3935                         uint32 writedata = 0;
3936                         uint32 inhibit   = 0;
3937                         srcdata = READ_PIXEL_8(a2);
3938                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
3939                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
3940                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
3941                         if (!inhibit)
3942                         {
3943                                 writedata |= srcdata  & ~dstdata;
3944                                 writedata |= srcdata  & dstdata;
3945                         } else { srczdata=dstzdata; writedata=dstdata; }
3946                         if (!inhibit)
3947                         {
3948                                 WRITE_PIXEL_8(a1, writedata);
3949                         }
3950                         a1_x += a1_xadd;
3951                         a1_y += a1_yadd;
3952                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3953                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3954                 }
3955                 a1_x+=a1_step_x;
3956                 a1_y+=a1_step_y;
3957                 a2_x+=a2_step_x;
3958                 a2_y+=a2_step_y;
3959         }
3960         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
3961         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
3962         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
3963 }
3964 #endif
3965 #ifndef blitter_code_0x00c0029b
3966 #define blitter_code_0x00c0029b
3967 void blitter_0x00c0029b(void)
3968 {
3969         while (outer_loop--)
3970         {
3971                 inner_loop=n_pixels;
3972                 while (inner_loop--)
3973                 {
3974                         uint32 srcdata   = 0;
3975                         uint32 srczdata  = 0;
3976                         uint32 dstdata   = 0;
3977                         uint32 dstzdata  = 0;
3978                         uint32 writedata = 0;
3979                         uint32 inhibit   = 0;
3980                         srcdata = READ_PIXEL_8(a2);
3981                         dstdata = READ_PIXEL_8(a1);
3982                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
3983                         if (!inhibit)
3984                         {
3985                                 writedata |= srcdata  & ~dstdata;
3986                                 writedata |= srcdata  & dstdata;
3987                         } else { srczdata=dstzdata; writedata=dstdata; }
3988                         if (!inhibit)
3989                         {
3990                                 WRITE_PIXEL_8(a1, writedata);
3991                         }
3992                         a1_x += a1_xadd;
3993                         a1_y += a1_yadd;
3994                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
3995                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
3996                 }
3997                 a1_x+=a1_step_x;
3998                 a1_y+=a1_step_y;
3999                 a2_x+=a2_step_x;
4000                 a2_y+=a2_step_y;
4001         }
4002         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4003         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4004         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4005 }
4006 #endif
4007 #ifndef blitter_code_0x20c00003
4008 #define blitter_code_0x20c00003
4009 void blitter_0x20c00003(void)
4010 {
4011         while (outer_loop--)
4012         {
4013                 inner_loop=n_pixels;
4014                 while (inner_loop--)
4015                 {
4016                         uint32 srcdata   = 0;
4017                         uint32 srczdata  = 0;
4018                         uint32 dstdata   = 0;
4019                         uint32 dstzdata  = 0;
4020                         uint32 writedata = 0;
4021                         uint32 inhibit   = 0;
4022                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
4023                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
4024                                 writedata |= srcdata  & ~dstdata;
4025                                 writedata |= srcdata  & dstdata;
4026                                 WRITE_PIXEL_8(a1, writedata);
4027                         a1_x += a1_xadd;
4028                         a1_y += a1_yadd;
4029                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4030                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4031                 }
4032                 a1_x+=a1_step_x;
4033                 a1_y+=a1_step_y;
4034                 a2_x+=a2_step_x;
4035                 a2_y+=a2_step_y;
4036         }
4037         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4038         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4039         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4040 }
4041 #endif
4042 #ifndef blitter_code_0x00c0001b
4043 #define blitter_code_0x00c0001b
4044 void blitter_0x00c0001b(void)
4045 {
4046         while (outer_loop--)
4047         {
4048                 inner_loop=n_pixels;
4049                 while (inner_loop--)
4050                 {
4051                         uint32 srcdata   = 0;
4052                         uint32 srczdata  = 0;
4053                         uint32 dstdata   = 0;
4054                         uint32 dstzdata  = 0;
4055                         uint32 writedata = 0;
4056                         uint32 inhibit   = 0;
4057                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
4058                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
4059                                 writedata |= srcdata  & ~dstdata;
4060                                 writedata |= srcdata  & dstdata;
4061                                 WRITE_PIXEL_8(a1, writedata);
4062                         a1_x += a1_xadd;
4063                         a1_y += a1_yadd;
4064                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4065                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4066                 }
4067                 a1_x+=a1_step_x;
4068                 a1_y+=a1_step_y;
4069                 a2_x+=a2_step_x;
4070                 a2_y+=a2_step_y;
4071         }
4072         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4073         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4074         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4075 }
4076 #endif
4077 #ifndef blitter_code_0x20c0002b
4078 #define blitter_code_0x20c0002b
4079 void blitter_0x20c0002b(void)
4080 {
4081         while (outer_loop--)
4082         {
4083                 inner_loop=n_pixels;
4084                 while (inner_loop--)
4085                 {
4086                         uint32 srcdata   = 0;
4087                         uint32 srczdata  = 0;
4088                         uint32 dstdata   = 0;
4089                         uint32 dstzdata  = 0;
4090                         uint32 writedata = 0;
4091                         uint32 inhibit   = 0;
4092                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
4093                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
4094                                 writedata |= srcdata  & ~dstdata;
4095                                 writedata |= srcdata  & dstdata;
4096                                 WRITE_PIXEL_8(a1, writedata);
4097                         a1_x += a1_xadd;
4098                         a1_y += a1_yadd;
4099                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4100                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4101                 }
4102                 a1_x+=a1_step_x;
4103                 a1_y+=a1_step_y;
4104                 a2_x+=a2_step_x;
4105                 a2_y+=a2_step_y;
4106         }
4107         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4108         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4109         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4110 }
4111 #endif
4112 #ifndef blitter_code_0x30c0001c
4113 #define blitter_code_0x30c0001c
4114 void blitter_0x30c0001c(void)
4115 {
4116         while (outer_loop--)
4117         {
4118                 inner_loop=n_pixels;
4119                 while (inner_loop--)
4120                 {
4121                         uint32 srcdata   = 0;
4122                         uint32 srczdata  = 0;
4123                         uint32 dstdata   = 0;
4124                         uint32 dstzdata  = 0;
4125                         uint32 writedata = 0;
4126                         uint32 inhibit   = 0;
4127                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4128                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4129                                 writedata |= srcdata  & ~dstdata;
4130                                 writedata |= srcdata  & dstdata;
4131                         WRITE_PIXEL_16(a1, writedata);
4132                         a1_x += a1_xadd;
4133                         a1_y += a1_yadd;
4134                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4135                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4136                 }
4137                 a1_x+=a1_step_x;
4138                 a1_y+=a1_step_y;
4139                 a2_x+=a2_step_x;
4140                 a2_y+=a2_step_y;
4141         }
4142         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4143         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4144         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4145 }
4146 #endif
4147 #ifndef blitter_code_0x00c000db
4148 #define blitter_code_0x00c000db
4149 void blitter_0x00c000db(void)
4150 {
4151         while (outer_loop--)
4152         {
4153                 inner_loop=n_pixels;
4154                 while (inner_loop--)
4155                 {
4156                         uint32 srcdata   = 0;
4157                         uint32 srczdata  = 0;
4158                         uint32 dstdata   = 0;
4159                         uint32 dstzdata  = 0;
4160                         uint32 writedata = 0;
4161                         uint32 inhibit   = 0;
4162                         srcdata = READ_PIXEL_8(a1);
4163                         dstdata = READ_RDATA_8(DSTDATA, a2, a2_phrase_mode);
4164                                 writedata |= srcdata  & ~dstdata;
4165                                 writedata |= srcdata  & dstdata;
4166                                 WRITE_PIXEL_8(a2, writedata);
4167                         a1_x += a1_xadd;
4168                         a1_y += a1_yadd;
4169                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4170                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4171                 }
4172                 a1_x+=a1_step_x;
4173                 a1_y+=a1_step_y;
4174                 a2_x+=a2_step_x;
4175                 a2_y+=a2_step_y;
4176         }
4177         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4178         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4179         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4180 }
4181 #endif
4182 #ifndef blitter_code_0x00c00023
4183 #define blitter_code_0x00c00023
4184 void blitter_0x00c00023(void)
4185 {
4186         while (outer_loop--)
4187         {
4188                 inner_loop=n_pixels;
4189                 while (inner_loop--)
4190                 {
4191                         uint32 srcdata   = 0;
4192                         uint32 srczdata  = 0;
4193                         uint32 dstdata   = 0;
4194                         uint32 dstzdata  = 0;
4195                         uint32 writedata = 0;
4196                         uint32 inhibit   = 0;
4197                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
4198                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
4199                                 writedata |= srcdata  & ~dstdata;
4200                                 writedata |= srcdata  & dstdata;
4201                                 WRITE_PIXEL_8(a1, writedata);
4202                         a1_x += a1_xadd;
4203                         a1_y += a1_yadd;
4204                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4205                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4206                 }
4207                 a1_x+=a1_step_x;
4208                 a1_y+=a1_step_y;
4209                 a2_x+=a2_step_x;
4210                 a2_y+=a2_step_y;
4211         }
4212         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4213         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4214         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4215 }
4216 #endif
4217 #ifndef blitter_code_0x34c10024
4218 #define blitter_code_0x34c10024
4219 void blitter_0x34c10024(void)
4220 {
4221         while (outer_loop--)
4222         {
4223                 inner_loop=n_pixels;
4224                 while (inner_loop--)
4225                 {
4226                         uint32 srcdata   = 0;
4227                         uint32 srczdata  = 0;
4228                         uint32 dstdata   = 0;
4229                         uint32 dstzdata  = 0;
4230                         uint32 writedata = 0;
4231                         uint32 inhibit   = 0;
4232                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4233                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4234                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4235                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4236                         WRITE_PIXEL_16(a1, writedata);
4237                         a1_x += a1_xadd;
4238                         a1_y += a1_yadd;
4239                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4240                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4241                 }
4242                 a1_x+=a1_step_x;
4243                 a1_y+=a1_step_y;
4244                 a2_x+=a2_step_x;
4245                 a2_y+=a2_step_y;
4246         }
4247         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4248         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4249         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4250 }
4251 #endif
4252 #ifndef blitter_code_0x3cc10024
4253 #define blitter_code_0x3cc10024
4254 void blitter_0x3cc10024(void)
4255 {
4256         while (outer_loop--)
4257         {
4258                 inner_loop=n_pixels;
4259                 while (inner_loop--)
4260                 {
4261                         uint32 srcdata   = 0;
4262                         uint32 srczdata  = 0;
4263                         uint32 dstdata   = 0;
4264                         uint32 dstzdata  = 0;
4265                         uint32 writedata = 0;
4266                         uint32 inhibit   = 0;
4267                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4268                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4269                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4270                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
4271                         if (!inhibit)
4272                         {
4273                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4274                         } else { srczdata=dstzdata; writedata=dstdata; }
4275                         WRITE_PIXEL_16(a1, writedata);
4276                         a1_x += a1_xadd;
4277                         a1_y += a1_yadd;
4278                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4279                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4280                 }
4281                 a1_x+=a1_step_x;
4282                 a1_y+=a1_step_y;
4283                 a2_x+=a2_step_x;
4284                 a2_y+=a2_step_y;
4285         }
4286         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4287         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4288         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4289 }
4290 #endif
4291 #ifndef blitter_code_0x04c10084
4292 #define blitter_code_0x04c10084
4293 void blitter_0x04c10084(void)
4294 {
4295         while (outer_loop--)
4296         {
4297                 inner_loop=n_pixels;
4298                 while (inner_loop--)
4299                 {
4300                         uint32 srcdata   = 0;
4301                         uint32 srczdata  = 0;
4302                         uint32 dstdata   = 0;
4303                         uint32 dstzdata  = 0;
4304                         uint32 writedata = 0;
4305                         uint32 inhibit   = 0;
4306                         srcdata = READ_PIXEL_16(a2);
4307                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
4308                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4309                         if (!inhibit)
4310                         {
4311                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4312                         } else { srczdata=dstzdata; writedata=dstdata; }
4313                         if (!inhibit)
4314                         {
4315                                 WRITE_PIXEL_16(a1, writedata);
4316                         }
4317                         a1_x += a1_xadd;
4318                         a1_y += a1_yadd;
4319                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4320                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4321                 }
4322                 a1_x+=a1_step_x;
4323                 a1_y+=a1_step_y;
4324                 a2_x+=a2_step_x;
4325                 a2_y+=a2_step_y;
4326         }
4327         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4328         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4329         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4330 }
4331 #endif
4332 #ifndef blitter_code_0x04010004
4333 #define blitter_code_0x04010004
4334 void blitter_0x04010004(void)
4335 {
4336         while (outer_loop--)
4337         {
4338                 inner_loop=n_pixels;
4339                 while (inner_loop--)
4340                 {
4341                         uint32 srcdata   = 0;
4342                         uint32 srczdata  = 0;
4343                         uint32 dstdata   = 0;
4344                         uint32 dstzdata  = 0;
4345                         uint32 writedata = 0;
4346                         uint32 inhibit   = 0;
4347                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4348                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4349                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4350                         if (!inhibit)
4351                         {
4352                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4353                         } else { srczdata=dstzdata; writedata=dstdata; }
4354                         if (!inhibit)
4355                         {
4356                                 WRITE_PIXEL_16(a1, writedata);
4357                         }
4358                         a1_x += a1_xadd;
4359                         a1_y += a1_yadd;
4360                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4361                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4362                 }
4363                 a1_x+=a1_step_x;
4364                 a1_y+=a1_step_y;
4365                 a2_x+=a2_step_x;
4366                 a2_y+=a2_step_y;
4367         }
4368         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4369         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4370         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4371 }
4372 #endif
4373 #ifndef blitter_code_0x30c000e4
4374 #define blitter_code_0x30c000e4
4375 void blitter_0x30c000e4(void)
4376 {
4377         while (outer_loop--)
4378         {
4379                 inner_loop=n_pixels;
4380                 while (inner_loop--)
4381                 {
4382                         uint32 srcdata   = 0;
4383                         uint32 srczdata  = 0;
4384                         uint32 dstdata   = 0;
4385                         uint32 dstzdata  = 0;
4386                         uint32 writedata = 0;
4387                         uint32 inhibit   = 0;
4388                         srcdata = READ_PIXEL_16(a1);
4389                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
4390                         if (!inhibit)
4391                         {
4392                                 writedata |= srcdata  & ~dstdata;
4393                                 writedata |= srcdata  & dstdata;
4394                         } else { srczdata=dstzdata; writedata=dstdata; }
4395                         WRITE_PIXEL_16(a2, writedata);
4396                         a1_x += a1_xadd;
4397                         a1_y += a1_yadd;
4398                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4399                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4400                 }
4401                 a1_x+=a1_step_x;
4402                 a1_y+=a1_step_y;
4403                 a2_x+=a2_step_x;
4404                 a2_y+=a2_step_y;
4405         }
4406         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4407         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4408         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4409 }
4410 #endif
4411 #ifndef blitter_code_0x04c10004
4412 #define blitter_code_0x04c10004
4413 void blitter_0x04c10004(void)
4414 {
4415         while (outer_loop--)
4416         {
4417                 inner_loop=n_pixels;
4418                 while (inner_loop--)
4419                 {
4420                         uint32 srcdata   = 0;
4421                         uint32 srczdata  = 0;
4422                         uint32 dstdata   = 0;
4423                         uint32 dstzdata  = 0;
4424                         uint32 writedata = 0;
4425                         uint32 inhibit   = 0;
4426                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4427                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4428                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4429                         if (!inhibit)
4430                         {
4431                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4432                         } else { srczdata=dstzdata; writedata=dstdata; }
4433                         if (!inhibit)
4434                         {
4435                                 WRITE_PIXEL_16(a1, writedata);
4436                         }
4437                         a1_x += a1_xadd;
4438                         a1_y += a1_yadd;
4439                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4440                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4441                 }
4442                 a1_x+=a1_step_x;
4443                 a1_y+=a1_step_y;
4444                 a2_x+=a2_step_x;
4445                 a2_y+=a2_step_y;
4446         }
4447         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4448         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4449         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4450 }
4451 #endif
4452 #ifndef blitter_code_0x0cc10004
4453 #define blitter_code_0x0cc10004
4454 void blitter_0x0cc10004(void)
4455 {
4456         while (outer_loop--)
4457         {
4458                 inner_loop=n_pixels;
4459                 while (inner_loop--)
4460                 {
4461                         uint32 srcdata   = 0;
4462                         uint32 srczdata  = 0;
4463                         uint32 dstdata   = 0;
4464                         uint32 dstzdata  = 0;
4465                         uint32 writedata = 0;
4466                         uint32 inhibit   = 0;
4467                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4468                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4469                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4470                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
4471                         if (!inhibit)
4472                         {
4473                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4474                         } else { srczdata=dstzdata; writedata=dstdata; }
4475                         if (!inhibit)
4476                         {
4477                                 WRITE_PIXEL_16(a1, writedata);
4478                         }
4479                         a1_x += a1_xadd;
4480                         a1_y += a1_yadd;
4481                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4482                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4483                 }
4484                 a1_x+=a1_step_x;
4485                 a1_y+=a1_step_y;
4486                 a2_x+=a2_step_x;
4487                 a2_y+=a2_step_y;
4488         }
4489         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4490         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4491         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4492 }
4493 #endif
4494 #ifndef blitter_code_0x1cc10024
4495 #define blitter_code_0x1cc10024
4496 void blitter_0x1cc10024(void)
4497 {
4498         while (outer_loop--)
4499         {
4500                 inner_loop=n_pixels;
4501                 while (inner_loop--)
4502                 {
4503                         uint32 srcdata   = 0;
4504                         uint32 srczdata  = 0;
4505                         uint32 dstdata   = 0;
4506                         uint32 dstzdata  = 0;
4507                         uint32 writedata = 0;
4508                         uint32 inhibit   = 0;
4509                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4510                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4511                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4512                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
4513                         if (!inhibit)
4514                         {
4515                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4516                         } else { srczdata=dstzdata; writedata=dstdata; }
4517                         WRITE_PIXEL_16(a1, writedata);
4518                         a1_x += a1_xadd;
4519                         a1_y += a1_yadd;
4520                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4521                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4522                 }
4523                 a1_x+=a1_step_x;
4524                 a1_y+=a1_step_y;
4525                 a2_x+=a2_step_x;
4526                 a2_y+=a2_step_y;
4527         }
4528         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4529         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4530         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4531 }
4532 #endif
4533 #ifndef blitter_code_0x0cc10084
4534 #define blitter_code_0x0cc10084
4535 void blitter_0x0cc10084(void)
4536 {
4537         while (outer_loop--)
4538         {
4539                 inner_loop=n_pixels;
4540                 while (inner_loop--)
4541                 {
4542                         uint32 srcdata   = 0;
4543                         uint32 srczdata  = 0;
4544                         uint32 dstdata   = 0;
4545                         uint32 dstzdata  = 0;
4546                         uint32 writedata = 0;
4547                         uint32 inhibit   = 0;
4548                         srcdata = READ_PIXEL_16(a2);
4549                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
4550                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4551                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
4552                         if (!inhibit)
4553                         {
4554                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4555                         } else { srczdata=dstzdata; writedata=dstdata; }
4556                         if (!inhibit)
4557                         {
4558                                 WRITE_PIXEL_16(a1, writedata);
4559                         }
4560                         a1_x += a1_xadd;
4561                         a1_y += a1_yadd;
4562                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4563                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4564                 }
4565                 a1_x+=a1_step_x;
4566                 a1_y+=a1_step_y;
4567                 a2_x+=a2_step_x;
4568                 a2_y+=a2_step_y;
4569         }
4570         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4571         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4572         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4573 }
4574 #endif
4575 #ifndef blitter_code_0x24c10024
4576 #define blitter_code_0x24c10024
4577 void blitter_0x24c10024(void)
4578 {
4579         while (outer_loop--)
4580         {
4581                 inner_loop=n_pixels;
4582                 while (inner_loop--)
4583                 {
4584                         uint32 srcdata   = 0;
4585                         uint32 srczdata  = 0;
4586                         uint32 dstdata   = 0;
4587                         uint32 dstzdata  = 0;
4588                         uint32 writedata = 0;
4589                         uint32 inhibit   = 0;
4590                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4591                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4592                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4593                         if (!inhibit)
4594                         {
4595                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4596                         } else { srczdata=dstzdata; writedata=dstdata; }
4597                         if (!inhibit)
4598                         {
4599                                 WRITE_PIXEL_16(a1, writedata);
4600                         }
4601                         a1_x += a1_xadd;
4602                         a1_y += a1_yadd;
4603                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4604                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4605                 }
4606                 a1_x+=a1_step_x;
4607                 a1_y+=a1_step_y;
4608                 a2_x+=a2_step_x;
4609                 a2_y+=a2_step_y;
4610         }
4611         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4612         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4613         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4614 }
4615 #endif
4616 #ifndef blitter_code_0x2cc10024
4617 #define blitter_code_0x2cc10024
4618 void blitter_0x2cc10024(void)
4619 {
4620         while (outer_loop--)
4621         {
4622                 inner_loop=n_pixels;
4623                 while (inner_loop--)
4624                 {
4625                         uint32 srcdata   = 0;
4626                         uint32 srczdata  = 0;
4627                         uint32 dstdata   = 0;
4628                         uint32 dstzdata  = 0;
4629                         uint32 writedata = 0;
4630                         uint32 inhibit   = 0;
4631                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4632                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4633                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4634                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
4635                         if (!inhibit)
4636                         {
4637                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4638                         } else { srczdata=dstzdata; writedata=dstdata; }
4639                         if (!inhibit)
4640                         {
4641                                 WRITE_PIXEL_16(a1, writedata);
4642                         }
4643                         a1_x += a1_xadd;
4644                         a1_y += a1_yadd;
4645                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4646                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4647                 }
4648                 a1_x+=a1_step_x;
4649                 a1_y+=a1_step_y;
4650                 a2_x+=a2_step_x;
4651                 a2_y+=a2_step_y;
4652         }
4653         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4654         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4655         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4656 }
4657 #endif
4658 #ifndef blitter_code_0x3401002c
4659 #define blitter_code_0x3401002c
4660 void blitter_0x3401002c(void)
4661 {
4662         while (outer_loop--)
4663         {
4664                 inner_loop=n_pixels;
4665                 while (inner_loop--)
4666                 {
4667                         uint32 srcdata   = 0;
4668                         uint32 srczdata  = 0;
4669                         uint32 dstdata   = 0;
4670                         uint32 dstzdata  = 0;
4671                         uint32 writedata = 0;
4672                         uint32 inhibit   = 0;
4673                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4674                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4675                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4676                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4677                         WRITE_PIXEL_16(a1, writedata);
4678                         a1_x += a1_xadd;
4679                         a1_y += a1_yadd;
4680                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4681                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4682                 }
4683                 a1_x+=a1_step_x;
4684                 a1_y+=a1_step_y;
4685                 a2_x+=a2_step_x;
4686                 a2_y+=a2_step_y;
4687         }
4688         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4689         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4690         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4691 }
4692 #endif
4693 #ifndef blitter_code_0x14010014
4694 #define blitter_code_0x14010014
4695 void blitter_0x14010014(void)
4696 {
4697         while (outer_loop--)
4698         {
4699                 inner_loop=n_pixels;
4700                 while (inner_loop--)
4701                 {
4702                         uint32 srcdata   = 0;
4703                         uint32 srczdata  = 0;
4704                         uint32 dstdata   = 0;
4705                         uint32 dstzdata  = 0;
4706                         uint32 writedata = 0;
4707                         uint32 inhibit   = 0;
4708                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4709                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
4710                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4711                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
4712                         WRITE_PIXEL_16(a1, writedata);
4713                         a1_x += a1_xadd;
4714                         a1_y += a1_yadd;
4715                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4716                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4717                 }
4718                 a1_x+=a1_step_x;
4719                 a1_y+=a1_step_y;
4720                 a2_x+=a2_step_x;
4721                 a2_y+=a2_step_y;
4722         }
4723         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4724         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4725         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4726 }
4727 #endif
4728 #ifndef blitter_code_0x14010013
4729 #define blitter_code_0x14010013
4730 void blitter_0x14010013(void)
4731 {
4732         while (outer_loop--)
4733         {
4734                 inner_loop=n_pixels;
4735                 while (inner_loop--)
4736                 {
4737                         uint32 srcdata   = 0;
4738                         uint32 srczdata  = 0;
4739                         uint32 dstdata   = 0;
4740                         uint32 dstzdata  = 0;
4741                         uint32 writedata = 0;
4742                         uint32 inhibit   = 0;
4743                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
4744                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
4745                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
4746                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
4747                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
4748                         WRITE_PIXEL_8(a1, writedata);
4749                         a1_x += a1_xadd;
4750                         a1_y += a1_yadd;
4751                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4752                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4753                         gd_i[colour_index] += gd_ia;
4754                         gd_c[colour_index] += gd_ca;
4755                          colour_index=(colour_index+1)&0x3;
4756                 }
4757                 a1_x+=a1_step_x;
4758                 a1_y+=a1_step_y;
4759                 a2_x+=a2_step_x;
4760                 a2_y+=a2_step_y;
4761         }
4762         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4763         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4764         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4765 }
4766 #endif
4767 #ifndef blitter_code_0x30000005
4768 #define blitter_code_0x30000005
4769 void blitter_0x30000005(void)
4770 {
4771         while (outer_loop--)
4772         {
4773                 inner_loop=n_pixels;
4774                 while (inner_loop--)
4775                 {
4776                         uint32 srcdata   = 0;
4777                         uint32 srczdata  = 0;
4778                         uint32 dstdata   = 0;
4779                         uint32 dstzdata  = 0;
4780                         uint32 writedata = 0;
4781                         uint32 inhibit   = 0;
4782                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
4783                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
4784                         WRITE_PIXEL_32(a1, writedata);
4785                         a1_x += a1_xadd;
4786                         a1_y += a1_yadd;
4787                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4788                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4789                 }
4790                 a1_x+=a1_step_x;
4791                 a1_y+=a1_step_y;
4792                 a2_x+=a2_step_x;
4793                 a2_y+=a2_step_y;
4794         }
4795         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4796         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4797         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4798 }
4799 #endif
4800 #ifndef blitter_code_0x3000001d
4801 #define blitter_code_0x3000001d
4802 void blitter_0x3000001d(void)
4803 {
4804         while (outer_loop--)
4805         {
4806                 inner_loop=n_pixels;
4807                 while (inner_loop--)
4808                 {
4809                         uint32 srcdata   = 0;
4810                         uint32 srczdata  = 0;
4811                         uint32 dstdata   = 0;
4812                         uint32 dstzdata  = 0;
4813                         uint32 writedata = 0;
4814                         uint32 inhibit   = 0;
4815                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
4816                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
4817                         WRITE_PIXEL_32(a1, writedata);
4818                         a1_x += a1_xadd;
4819                         a1_y += a1_yadd;
4820                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4821                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4822                 }
4823                 a1_x+=a1_step_x;
4824                 a1_y+=a1_step_y;
4825                 a2_x+=a2_step_x;
4826                 a2_y+=a2_step_y;
4827         }
4828         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4829         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4830         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4831 }
4832 #endif
4833 #ifndef blitter_code_0x30c0002c
4834 #define blitter_code_0x30c0002c
4835 void blitter_0x30c0002c(void)
4836 {
4837         while (outer_loop--)
4838         {
4839                 inner_loop=n_pixels;
4840                 while (inner_loop--)
4841                 {
4842                         uint32 srcdata   = 0;
4843                         uint32 srczdata  = 0;
4844                         uint32 dstdata   = 0;
4845                         uint32 dstzdata  = 0;
4846                         uint32 writedata = 0;
4847                         uint32 inhibit   = 0;
4848                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4849                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4850                                 writedata |= srcdata  & ~dstdata;
4851                                 writedata |= srcdata  & dstdata;
4852                         WRITE_PIXEL_16(a1, writedata);
4853                         a1_x += a1_xadd;
4854                         a1_y += a1_yadd;
4855                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4856                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4857                 }
4858                 a1_x+=a1_step_x;
4859                 a1_y+=a1_step_y;
4860                 a2_x+=a2_step_x;
4861                 a2_y+=a2_step_y;
4862         }
4863         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4864         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4865         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4866 }
4867 #endif
4868 #ifndef blitter_code_0x3000002d
4869 #define blitter_code_0x3000002d
4870 void blitter_0x3000002d(void)
4871 {
4872         while (outer_loop--)
4873         {
4874                 inner_loop=n_pixels;
4875                 while (inner_loop--)
4876                 {
4877                         uint32 srcdata   = 0;
4878                         uint32 srczdata  = 0;
4879                         uint32 dstdata   = 0;
4880                         uint32 dstzdata  = 0;
4881                         uint32 writedata = 0;
4882                         uint32 inhibit   = 0;
4883                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
4884                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
4885                         WRITE_PIXEL_32(a1, writedata);
4886                         a1_x += a1_xadd;
4887                         a1_y += a1_yadd;
4888                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4889                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4890                 }
4891                 a1_x+=a1_step_x;
4892                 a1_y+=a1_step_y;
4893                 a2_x+=a2_step_x;
4894                 a2_y+=a2_step_y;
4895         }
4896         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4897         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4898         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4899 }
4900 #endif
4901 #ifndef blitter_code_0x10000025
4902 #define blitter_code_0x10000025
4903 void blitter_0x10000025(void)
4904 {
4905         while (outer_loop--)
4906         {
4907                 inner_loop=n_pixels;
4908                 while (inner_loop--)
4909                 {
4910                         uint32 srcdata   = 0;
4911                         uint32 srczdata  = 0;
4912                         uint32 dstdata   = 0;
4913                         uint32 dstzdata  = 0;
4914                         uint32 writedata = 0;
4915                         uint32 inhibit   = 0;
4916                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
4917                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
4918                         WRITE_PIXEL_32(a1, writedata);
4919                         a1_x += a1_xadd;
4920                         a1_y += a1_yadd;
4921                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4922                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4923                 }
4924                 a1_x+=a1_step_x;
4925                 a1_y+=a1_step_y;
4926                 a2_x+=a2_step_x;
4927                 a2_y+=a2_step_y;
4928         }
4929         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4930         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4931         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4932 }
4933 #endif
4934 #ifndef blitter_code_0x28c0002c
4935 #define blitter_code_0x28c0002c
4936 void blitter_0x28c0002c(void)
4937 {
4938         while (outer_loop--)
4939         {
4940                 inner_loop=n_pixels;
4941                 while (inner_loop--)
4942                 {
4943                         uint32 srcdata   = 0;
4944                         uint32 srczdata  = 0;
4945                         uint32 dstdata   = 0;
4946                         uint32 dstzdata  = 0;
4947                         uint32 writedata = 0;
4948                         uint32 inhibit   = 0;
4949                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4950                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
4951                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
4952                         if (!inhibit)
4953                         {
4954                                 writedata |= srcdata  & ~dstdata;
4955                                 writedata |= srcdata  & dstdata;
4956                         } else { srczdata=dstzdata; writedata=dstdata; }
4957                         if (!inhibit)
4958                         {
4959                                 WRITE_PIXEL_16(a1, writedata);
4960                         }
4961                         a1_x += a1_xadd;
4962                         a1_y += a1_yadd;
4963                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
4964                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
4965                 }
4966                 a1_x+=a1_step_x;
4967                 a1_y+=a1_step_y;
4968                 a2_x+=a2_step_x;
4969                 a2_y+=a2_step_y;
4970         }
4971         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
4972         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
4973         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
4974 }
4975 #endif
4976 #ifndef blitter_code_0x3002022c
4977 #define blitter_code_0x3002022c
4978 void blitter_0x3002022c(void)
4979 {
4980         while (outer_loop--)
4981         {
4982                 inner_loop=n_pixels;
4983                 while (inner_loop--)
4984                 {
4985                         uint32 srcdata   = 0;
4986                         uint32 srczdata  = 0;
4987                         uint32 dstdata   = 0;
4988                         uint32 dstzdata  = 0;
4989                         uint32 writedata = 0;
4990                         uint32 inhibit   = 0;
4991                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
4992                         dstdata = READ_PIXEL_16(a1);
4993                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
4994                         if (!inhibit)
4995                         {
4996                                 writedata = (srcdata & 0xff) + (dstdata & 0xff);
4997                                 if (writedata > 0xff) writedata = 0xff;
4998                                 writedata |= (srcdata & 0xf00) + (dstdata & 0xf00);
4999                                 if (writedata > 0xfff) writedata = 0xfff;
5000                                 writedata |= (srcdata & 0xf000) + (dstdata & 0xf000);
5001                         } else { srczdata=dstzdata; writedata=dstdata; }
5002                         WRITE_PIXEL_16(a1, writedata);
5003                         a1_x += a1_xadd;
5004                         a1_y += a1_yadd;
5005                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5006                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5007                 }
5008                 a1_x+=a1_step_x;
5009                 a1_y+=a1_step_y;
5010                 a2_x+=a2_step_x;
5011                 a2_y+=a2_step_y;
5012         }
5013         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5014         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5015         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5016 }
5017 #endif
5018 #ifndef blitter_code_0x08c040e4
5019 #define blitter_code_0x08c040e4
5020 void blitter_0x08c040e4(void)
5021 {
5022         while (outer_loop--)
5023         {
5024                 inner_loop=n_pixels;
5025                 while (inner_loop--)
5026                 {
5027                         uint32 srcdata   = 0;
5028                         uint32 srczdata  = 0;
5029                         uint32 dstdata   = 0;
5030                         uint32 dstzdata  = 0;
5031                         uint32 writedata = 0;
5032                         uint32 inhibit   = 0;
5033                         srcdata = READ_PIXEL_16(a1);
5034                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
5035                         if (srcdata == READ_RDATA_16(PATTERNDATA, a1,a1_phrase_mode)) inhibit=1;
5036                         if (!inhibit)
5037                         {
5038                                 writedata |= srcdata  & ~dstdata;
5039                                 writedata |= srcdata  & dstdata;
5040                         } else { srczdata=dstzdata; writedata=dstdata; }
5041                         if (!inhibit)
5042                         {
5043                                 WRITE_PIXEL_16(a2, writedata);
5044                         }
5045                         a1_x += a1_xadd;
5046                         a1_y += a1_yadd;
5047                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5048                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5049                 }
5050                 a1_x+=a1_step_x;
5051                 a1_y+=a1_step_y;
5052                 a2_x+=a2_step_x;
5053                 a2_y+=a2_step_y;
5054         }
5055         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5056         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5057         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5058 }
5059 #endif
5060 #ifndef blitter_code_0x30c042a4
5061 #define blitter_code_0x30c042a4
5062 void blitter_0x30c042a4(void)
5063 {
5064         while (outer_loop--)
5065         {
5066                 inner_loop=n_pixels;
5067                 while (inner_loop--)
5068                 {
5069                         uint32 srcdata   = 0;
5070                         uint32 srczdata  = 0;
5071                         uint32 dstdata   = 0;
5072                         uint32 dstzdata  = 0;
5073                         uint32 writedata = 0;
5074                         uint32 inhibit   = 0;
5075                         srcdata = READ_PIXEL_16(a2);
5076                         dstdata = READ_PIXEL_16(a1);
5077                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
5078                         if (srcdata == READ_RDATA_16(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
5079                         if (!inhibit)
5080                         {
5081                                 writedata |= srcdata  & ~dstdata;
5082                                 writedata |= srcdata  & dstdata;
5083                         } else { srczdata=dstzdata; writedata=dstdata; }
5084                         WRITE_PIXEL_16(a1, writedata);
5085                         a1_x += a1_xadd;
5086                         a1_y += a1_yadd;
5087                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5088                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5089                 }
5090                 a1_x+=a1_step_x;
5091                 a1_y+=a1_step_y;
5092                 a2_x+=a2_step_x;
5093                 a2_y+=a2_step_y;
5094         }
5095         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5096         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5097         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5098 }
5099 #endif
5100 #ifndef blitter_code_0x3401002b
5101 #define blitter_code_0x3401002b
5102 void blitter_0x3401002b(void)
5103 {
5104         while (outer_loop--)
5105         {
5106                 inner_loop=n_pixels;
5107                 while (inner_loop--)
5108                 {
5109                         uint32 srcdata   = 0;
5110                         uint32 srczdata  = 0;
5111                         uint32 dstdata   = 0;
5112                         uint32 dstzdata  = 0;
5113                         uint32 writedata = 0;
5114                         uint32 inhibit   = 0;
5115                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
5116                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
5117                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
5118                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
5119                         WRITE_PIXEL_8(a1, writedata);
5120                         a1_x += a1_xadd;
5121                         a1_y += a1_yadd;
5122                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5123                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5124                 }
5125                 a1_x+=a1_step_x;
5126                 a1_y+=a1_step_y;
5127                 a2_x+=a2_step_x;
5128                 a2_y+=a2_step_y;
5129         }
5130         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5131         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5132         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5133 }
5134 #endif
5135 #ifndef blitter_code_0x14010005
5136 #define blitter_code_0x14010005
5137 void blitter_0x14010005(void)
5138 {
5139         while (outer_loop--)
5140         {
5141                 inner_loop=n_pixels;
5142                 while (inner_loop--)
5143                 {
5144                         uint32 srcdata   = 0;
5145                         uint32 srczdata  = 0;
5146                         uint32 dstdata   = 0;
5147                         uint32 dstzdata  = 0;
5148                         uint32 writedata = 0;
5149                         uint32 inhibit   = 0;
5150                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
5151                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
5152                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
5153                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
5154                         WRITE_PIXEL_32(a1, writedata);
5155                         a1_x += a1_xadd;
5156                         a1_y += a1_yadd;
5157                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5158                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5159                 }
5160                 a1_x+=a1_step_x;
5161                 a1_y+=a1_step_y;
5162                 a2_x+=a2_step_x;
5163                 a2_y+=a2_step_y;
5164         }
5165         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5166         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5167         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5168 }
5169 #endif
5170 #ifndef blitter_code_0x2c01001b
5171 #define blitter_code_0x2c01001b
5172 void blitter_0x2c01001b(void)
5173 {
5174         while (outer_loop--)
5175         {
5176                 inner_loop=n_pixels;
5177                 while (inner_loop--)
5178                 {
5179                         uint32 srcdata   = 0;
5180                         uint32 srczdata  = 0;
5181                         uint32 dstdata   = 0;
5182                         uint32 dstzdata  = 0;
5183                         uint32 writedata = 0;
5184                         uint32 inhibit   = 0;
5185                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
5186                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
5187                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
5188                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
5189                         if (!inhibit)
5190                         {
5191                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
5192                         } else { srczdata=dstzdata; writedata=dstdata; }
5193                         if (!inhibit)
5194                         {
5195                                 WRITE_PIXEL_8(a1, writedata);
5196                         }
5197                         a1_x += a1_xadd;
5198                         a1_y += a1_yadd;
5199                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5200                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5201                 }
5202                 a1_x+=a1_step_x;
5203                 a1_y+=a1_step_y;
5204                 a2_x+=a2_step_x;
5205                 a2_y+=a2_step_y;
5206         }
5207         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5208         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5209         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5210 }
5211 #endif
5212 #ifndef blitter_code_0x3401001c
5213 #define blitter_code_0x3401001c
5214 void blitter_0x3401001c(void)
5215 {
5216         while (outer_loop--)
5217         {
5218                 inner_loop=n_pixels;
5219                 while (inner_loop--)
5220                 {
5221                         uint32 srcdata   = 0;
5222                         uint32 srczdata  = 0;
5223                         uint32 dstdata   = 0;
5224                         uint32 dstzdata  = 0;
5225                         uint32 writedata = 0;
5226                         uint32 inhibit   = 0;
5227                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
5228                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
5229                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
5230                         if (!inhibit)
5231                         {
5232                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
5233                         } else { srczdata=dstzdata; writedata=dstdata; }
5234                         WRITE_PIXEL_16(a1, writedata);
5235                         a1_x += a1_xadd;
5236                         a1_y += a1_yadd;
5237                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5238                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5239                 }
5240                 a1_x+=a1_step_x;
5241                 a1_y+=a1_step_y;
5242                 a2_x+=a2_step_x;
5243                 a2_y+=a2_step_y;
5244         }
5245         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5246         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5247         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5248 }
5249 #endif
5250 #ifndef blitter_code_0x05010083
5251 #define blitter_code_0x05010083
5252 void blitter_0x05010083(void)
5253 {
5254         while (outer_loop--)
5255         {
5256                 inner_loop=n_pixels;
5257                 while (inner_loop--)
5258                 {
5259                         uint32 srcdata   = 0;
5260                         uint32 srczdata  = 0;
5261                         uint32 dstdata   = 0;
5262                         uint32 dstzdata  = 0;
5263                         uint32 writedata = 0;
5264                         uint32 inhibit   = 0;
5265                         srcdata = READ_PIXEL_8(a2);
5266                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
5267                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
5268                         if (!inhibit)
5269                         {
5270                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
5271                         } else { srczdata=dstzdata; writedata=dstdata; }
5272                         WRITE_PIXEL_8(a1, writedata);
5273                         a1_x += a1_xadd;
5274                         a1_y += a1_yadd;
5275                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5276                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5277                 }
5278                 a1_x+=a1_step_x;
5279                 a1_y+=a1_step_y;
5280                 a2_x+=a2_step_x;
5281                 a2_y+=a2_step_y;
5282         }
5283         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5284         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5285         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5286 }
5287 #endif
5288 #ifndef blitter_code_0x05010084
5289 #define blitter_code_0x05010084
5290 void blitter_0x05010084(void)
5291 {
5292         while (outer_loop--)
5293         {
5294                 inner_loop=n_pixels;
5295                 while (inner_loop--)
5296                 {
5297                         uint32 srcdata   = 0;
5298                         uint32 srczdata  = 0;
5299                         uint32 dstdata   = 0;
5300                         uint32 dstzdata  = 0;
5301                         uint32 writedata = 0;
5302                         uint32 inhibit   = 0;
5303                         srcdata = READ_PIXEL_16(a2);
5304                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
5305                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
5306                         if (!inhibit)
5307                         {
5308                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
5309                         } else { srczdata=dstzdata; writedata=dstdata; }
5310                         WRITE_PIXEL_16(a1, writedata);
5311                         a1_x += a1_xadd;
5312                         a1_y += a1_yadd;
5313                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5314                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5315                 }
5316                 a1_x+=a1_step_x;
5317                 a1_y+=a1_step_y;
5318                 a2_x+=a2_step_x;
5319                 a2_y+=a2_step_y;
5320         }
5321         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5322         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5323         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5324 }
5325 #endif
5326 #ifndef blitter_code_0x34010064
5327 #define blitter_code_0x34010064
5328 void blitter_0x34010064(void)
5329 {
5330         while (outer_loop--)
5331         {
5332                 inner_loop=n_pixels;
5333                 while (inner_loop--)
5334                 {
5335                         uint32 srcdata   = 0;
5336                         uint32 srczdata  = 0;
5337                         uint32 dstdata   = 0;
5338                         uint32 dstzdata  = 0;
5339                         uint32 writedata = 0;
5340                         uint32 inhibit   = 0;
5341                         srcdata = READ_RDATA_16(SRCDATA, a1, a1_phrase_mode);
5342                         srczdata = READ_RDATA_16(SRCZINT, a1, a1_phrase_mode);
5343                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
5344                         if (!inhibit)
5345                         {
5346                                 writedata= READ_RDATA_16(PATTERNDATA, a2, a2_phrase_mode);
5347                         } else { srczdata=dstzdata; writedata=dstdata; }
5348                         WRITE_PIXEL_16(a2, writedata);
5349                         a1_x += a1_xadd;
5350                         a1_y += a1_yadd;
5351                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5352                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5353                 }
5354                 a1_x+=a1_step_x;
5355                 a1_y+=a1_step_y;
5356                 a2_x+=a2_step_x;
5357                 a2_y+=a2_step_y;
5358         }
5359         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5360         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5361         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5362 }
5363 #endif
5364 #ifndef blitter_code_0x14010064
5365 #define blitter_code_0x14010064
5366 void blitter_0x14010064(void)
5367 {
5368         while (outer_loop--)
5369         {
5370                 inner_loop=n_pixels;
5371                 while (inner_loop--)
5372                 {
5373                         uint32 srcdata   = 0;
5374                         uint32 srczdata  = 0;
5375                         uint32 dstdata   = 0;
5376                         uint32 dstzdata  = 0;
5377                         uint32 writedata = 0;
5378                         uint32 inhibit   = 0;
5379                         srcdata = READ_RDATA_16(SRCDATA, a1, a1_phrase_mode);
5380                         srczdata = READ_RDATA_16(SRCZINT, a1, a1_phrase_mode);
5381                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
5382                         if (!inhibit)
5383                         {
5384                                 writedata= READ_RDATA_16(PATTERNDATA, a2, a2_phrase_mode);
5385                         } else { srczdata=dstzdata; writedata=dstdata; }
5386                         if (!inhibit)
5387                         {
5388                                 WRITE_PIXEL_16(a2, writedata);
5389                         }
5390                         a1_x += a1_xadd;
5391                         a1_y += a1_yadd;
5392                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5393                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5394                 }
5395                 a1_x+=a1_step_x;
5396                 a1_y+=a1_step_y;
5397                 a2_x+=a2_step_x;
5398                 a2_y+=a2_step_y;
5399         }
5400         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5401         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5402         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5403 }
5404 #endif
5405 #ifndef blitter_code_0x2401021b
5406 #define blitter_code_0x2401021b
5407 void blitter_0x2401021b(void)
5408 {
5409         while (outer_loop--)
5410         {
5411                 inner_loop=n_pixels;
5412                 while (inner_loop--)
5413                 {
5414                         uint32 srcdata   = 0;
5415                         uint32 srczdata  = 0;
5416                         uint32 dstdata   = 0;
5417                         uint32 dstzdata  = 0;
5418                         uint32 writedata = 0;
5419                         uint32 inhibit   = 0;
5420                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
5421                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
5422                         dstdata = READ_PIXEL_8(a1);
5423                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
5424                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
5425                                 WRITE_PIXEL_8(a1, writedata);
5426                         a1_x += a1_xadd;
5427                         a1_y += a1_yadd;
5428                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5429                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5430                 }
5431                 a1_x+=a1_step_x;
5432                 a1_y+=a1_step_y;
5433                 a2_x+=a2_step_x;
5434                 a2_y+=a2_step_y;
5435         }
5436         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5437         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5438         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5439 }
5440 #endif
5441 #ifndef blitter_code_0x24010218
5442 #define blitter_code_0x24010218
5443 void blitter_0x24010218(void)
5444 {
5445         while (outer_loop--)
5446         {
5447                 inner_loop=n_pixels;
5448                 while (inner_loop--)
5449                 {
5450                         uint32 srcdata   = 0;
5451                         uint32 srczdata  = 0;
5452                         uint32 dstdata   = 0;
5453                         uint32 dstzdata  = 0;
5454                         uint32 writedata = 0;
5455                         uint32 inhibit   = 0;
5456                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
5457                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
5458                         dstdata = READ_PIXEL_1(a1);
5459                         dstzdata = READ_RDATA_1(DSTZ, a1, a1_phrase_mode);
5460                                 writedata= READ_RDATA_1(PATTERNDATA, a1, a1_phrase_mode);
5461                                 WRITE_PIXEL_1(a1, writedata);
5462                         a1_x += a1_xadd;
5463                         a1_y += a1_yadd;
5464                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5465                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5466                 }
5467                 a1_x+=a1_step_x;
5468                 a1_y+=a1_step_y;
5469                 a2_x+=a2_step_x;
5470                 a2_y+=a2_step_y;
5471         }
5472         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5473         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5474         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5475 }
5476 #endif
5477 #ifndef blitter_code_0x2401021a
5478 #define blitter_code_0x2401021a
5479 void blitter_0x2401021a(void)
5480 {
5481         while (outer_loop--)
5482         {
5483                 inner_loop=n_pixels;
5484                 while (inner_loop--)
5485                 {
5486                         uint32 srcdata   = 0;
5487                         uint32 srczdata  = 0;
5488                         uint32 dstdata   = 0;
5489                         uint32 dstzdata  = 0;
5490                         uint32 writedata = 0;
5491                         uint32 inhibit   = 0;
5492                         srcdata = READ_RDATA_4(SRCDATA, a2, a2_phrase_mode);
5493                         srczdata = READ_RDATA_4(SRCZINT, a2, a2_phrase_mode);
5494                         dstdata = READ_PIXEL_4(a1);
5495                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
5496                                 writedata= READ_RDATA_4(PATTERNDATA, a1, a1_phrase_mode);
5497                                 WRITE_PIXEL_4(a1, writedata);
5498                         a1_x += a1_xadd;
5499                         a1_y += a1_yadd;
5500                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5501                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5502                 }
5503                 a1_x+=a1_step_x;
5504                 a1_y+=a1_step_y;
5505                 a2_x+=a2_step_x;
5506                 a2_y+=a2_step_y;
5507         }
5508         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5509         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5510         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5511 }
5512 #endif
5513 #ifndef blitter_code_0x2401021c
5514 #define blitter_code_0x2401021c
5515 void blitter_0x2401021c(void)
5516 {
5517         while (outer_loop--)
5518         {
5519                 inner_loop=n_pixels;
5520                 while (inner_loop--)
5521                 {
5522                         uint32 srcdata   = 0;
5523                         uint32 srczdata  = 0;
5524                         uint32 dstdata   = 0;
5525                         uint32 dstzdata  = 0;
5526                         uint32 writedata = 0;
5527                         uint32 inhibit   = 0;
5528                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
5529                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
5530                         dstdata = READ_PIXEL_16(a1);
5531                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
5532                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
5533                                 WRITE_PIXEL_16(a1, writedata);
5534                         a1_x += a1_xadd;
5535                         a1_y += a1_yadd;
5536                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5537                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5538                 }
5539                 a1_x+=a1_step_x;
5540                 a1_y+=a1_step_y;
5541                 a2_x+=a2_step_x;
5542                 a2_y+=a2_step_y;
5543         }
5544         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5545         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5546         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5547 }
5548 #endif
5549 #ifndef blitter_code_0x00c00064
5550 #define blitter_code_0x00c00064
5551 void blitter_0x00c00064(void)
5552 {
5553         while (outer_loop--)
5554         {
5555                 inner_loop=n_pixels;
5556                 while (inner_loop--)
5557                 {
5558                         uint32 srcdata   = 0;
5559                         uint32 srczdata  = 0;
5560                         uint32 dstdata   = 0;
5561                         uint32 dstzdata  = 0;
5562                         uint32 writedata = 0;
5563                         uint32 inhibit   = 0;
5564                         srcdata = READ_RDATA_16(SRCDATA, a1, a1_phrase_mode);
5565                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
5566                                 writedata |= srcdata  & ~dstdata;
5567                                 writedata |= srcdata  & dstdata;
5568                                 WRITE_PIXEL_16(a2, writedata);
5569                         a1_x += a1_xadd;
5570                         a1_y += a1_yadd;
5571                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5572                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5573                 }
5574                 a1_x+=a1_step_x;
5575                 a1_y+=a1_step_y;
5576                 a2_x+=a2_step_x;
5577                 a2_y+=a2_step_y;
5578         }
5579         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5580         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5581         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5582 }
5583 #endif
5584 #ifndef blitter_code_0x00c00024
5585 #define blitter_code_0x00c00024
5586 void blitter_0x00c00024(void)
5587 {
5588         while (outer_loop--)
5589         {
5590                 inner_loop=n_pixels;
5591                 while (inner_loop--)
5592                 {
5593                         uint32 srcdata   = 0;
5594                         uint32 srczdata  = 0;
5595                         uint32 dstdata   = 0;
5596                         uint32 dstzdata  = 0;
5597                         uint32 writedata = 0;
5598                         uint32 inhibit   = 0;
5599                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
5600                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
5601                                 writedata |= srcdata  & ~dstdata;
5602                                 writedata |= srcdata  & dstdata;
5603                                 WRITE_PIXEL_16(a1, writedata);
5604                         a1_x += a1_xadd;
5605                         a1_y += a1_yadd;
5606                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5607                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5608                 }
5609                 a1_x+=a1_step_x;
5610                 a1_y+=a1_step_y;
5611                 a2_x+=a2_step_x;
5612                 a2_y+=a2_step_y;
5613         }
5614         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5615         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5616         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5617 }
5618 #endif
5619 #ifndef blitter_code_0x01c042e4
5620 #define blitter_code_0x01c042e4
5621 void blitter_0x01c042e4(void)
5622 {
5623         while (outer_loop--)
5624         {
5625                 inner_loop=n_pixels;
5626                 while (inner_loop--)
5627                 {
5628                         uint32 srcdata   = 0;
5629                         uint32 srczdata  = 0;
5630                         uint32 dstdata   = 0;
5631                         uint32 dstzdata  = 0;
5632                         uint32 writedata = 0;
5633                         uint32 inhibit   = 0;
5634                         srcdata = READ_PIXEL_16(a1);
5635                         dstdata = READ_PIXEL_16(a2);
5636                         dstzdata = READ_RDATA_16(DSTZ, a2, a2_phrase_mode);
5637                         srczdata=z_i[colour_index]>>16;
5638                         if (srcdata == READ_RDATA_16(PATTERNDATA, a1,a1_phrase_mode)) inhibit=1;
5639                         if (!inhibit)
5640                         {
5641                                 writedata |= srcdata  & ~dstdata;
5642                                 writedata |= srcdata  & dstdata;
5643                                 {
5644                                 int intensity = srcdata & 0xFF;
5645                                 int ia = gd_ia >> 16;
5646                                 if(ia & 0x80)
5647                                         ia = 0xFFFFFF00 | ia;
5648                                 intensity += ia;
5649                                 if(intensity < 0)
5650                                         intensity = 0;
5651                                 if(intensity > 0xFF)
5652                                         intensity = 0xFF;
5653                                 writedata = (srcdata & 0xFF00) | intensity;
5654                                 }
5655                         } else { srczdata=dstzdata; writedata=dstdata; }
5656                         WRITE_PIXEL_16(a2, writedata);
5657                         a1_x += a1_xadd;
5658                         a1_y += a1_yadd;
5659                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5660                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5661                         z_i[colour_index]+=zadd;
5662                         gd_i[colour_index] += gd_ia;
5663                         gd_c[colour_index] += gd_ca;
5664                 }
5665                 a1_x+=a1_step_x;
5666                 a1_y+=a1_step_y;
5667                 a2_x+=a2_step_x;
5668                 a2_y+=a2_step_y;
5669         }
5670         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5671         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5672         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5673 }
5674 #endif
5675 #ifndef blitter_code_0x20c0001c
5676 #define blitter_code_0x20c0001c
5677 void blitter_0x20c0001c(void)
5678 {
5679         while (outer_loop--)
5680         {
5681                 inner_loop=n_pixels;
5682                 while (inner_loop--)
5683                 {
5684                         uint32 srcdata   = 0;
5685                         uint32 srczdata  = 0;
5686                         uint32 dstdata   = 0;
5687                         uint32 dstzdata  = 0;
5688                         uint32 writedata = 0;
5689                         uint32 inhibit   = 0;
5690                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
5691                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
5692                         if (!inhibit)
5693                         {
5694                                 writedata |= srcdata  & ~dstdata;
5695                                 writedata |= srcdata  & dstdata;
5696                         } else { srczdata=dstzdata; writedata=dstdata; }
5697                         if (!inhibit)
5698                         {
5699                                 WRITE_PIXEL_16(a1, writedata);
5700                         }
5701                         a1_x += a1_xadd;
5702                         a1_y += a1_yadd;
5703                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5704                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5705                 }
5706                 a1_x+=a1_step_x;
5707                 a1_y+=a1_step_y;
5708                 a2_x+=a2_step_x;
5709                 a2_y+=a2_step_y;
5710         }
5711         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5712         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5713         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5714 }
5715 #endif
5716 #ifndef blitter_code_0x24010219
5717 #define blitter_code_0x24010219
5718 void blitter_0x24010219(void)
5719 {
5720         while (outer_loop--)
5721         {
5722                 inner_loop=n_pixels;
5723                 while (inner_loop--)
5724                 {
5725                         uint32 srcdata   = 0;
5726                         uint32 srczdata  = 0;
5727                         uint32 dstdata   = 0;
5728                         uint32 dstzdata  = 0;
5729                         uint32 writedata = 0;
5730                         uint32 inhibit   = 0;
5731                         srcdata = READ_RDATA_2(SRCDATA, a2, a2_phrase_mode);
5732                         srczdata = READ_RDATA_2(SRCZINT, a2, a2_phrase_mode);
5733                         dstdata = READ_PIXEL_2(a1);
5734                         dstzdata = READ_RDATA_2(DSTZ, a1, a1_phrase_mode);
5735                         if (!inhibit)
5736                         {
5737                                 writedata= READ_RDATA_2(PATTERNDATA, a1, a1_phrase_mode);
5738                         } else { srczdata=dstzdata; writedata=dstdata; }
5739                         if (!inhibit)
5740                         {
5741                                 WRITE_PIXEL_2(a1, writedata);
5742                         }
5743                         a1_x += a1_xadd;
5744                         a1_y += a1_yadd;
5745                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5746                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5747                 }
5748                 a1_x+=a1_step_x;
5749                 a1_y+=a1_step_y;
5750                 a2_x+=a2_step_x;
5751                 a2_y+=a2_step_y;
5752         }
5753         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5754         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5755         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5756 }
5757 #endif
5758 #ifndef blitter_code_0x08c000a4
5759 #define blitter_code_0x08c000a4
5760 void blitter_0x08c000a4(void)
5761 {
5762         while (outer_loop--)
5763         {
5764                 inner_loop=n_pixels;
5765                 while (inner_loop--)
5766                 {
5767                         uint32 srcdata   = 0;
5768                         uint32 srczdata  = 0;
5769                         uint32 dstdata   = 0;
5770                         uint32 dstzdata  = 0;
5771                         uint32 writedata = 0;
5772                         uint32 inhibit   = 0;
5773                         srcdata = READ_PIXEL_16(a2);
5774                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
5775                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
5776                         if (!inhibit)
5777                         {
5778                                 writedata |= srcdata  & ~dstdata;
5779                                 writedata |= srcdata  & dstdata;
5780                         } else { srczdata=dstzdata; writedata=dstdata; }
5781                         if (!inhibit)
5782                         {
5783                                 WRITE_PIXEL_16(a1, writedata);
5784                         }
5785                         a1_x += a1_xadd;
5786                         a1_y += a1_yadd;
5787                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5788                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5789                 }
5790                 a1_x+=a1_step_x;
5791                 a1_y+=a1_step_y;
5792                 a2_x+=a2_step_x;
5793                 a2_y+=a2_step_y;
5794         }
5795         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5796         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5797         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5798 }
5799 #endif
5800 #ifndef blitter_code_0x2c01001c
5801 #define blitter_code_0x2c01001c
5802 void blitter_0x2c01001c(void)
5803 {
5804         while (outer_loop--)
5805         {
5806                 inner_loop=n_pixels;
5807                 while (inner_loop--)
5808                 {
5809                         uint32 srcdata   = 0;
5810                         uint32 srczdata  = 0;
5811                         uint32 dstdata   = 0;
5812                         uint32 dstzdata  = 0;
5813                         uint32 writedata = 0;
5814                         uint32 inhibit   = 0;
5815                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
5816                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
5817                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
5818                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
5819                         if (!inhibit)
5820                         {
5821                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
5822                         } else { srczdata=dstzdata; writedata=dstdata; }
5823                         if (!inhibit)
5824                         {
5825                                 WRITE_PIXEL_16(a1, writedata);
5826                         }
5827                         a1_x += a1_xadd;
5828                         a1_y += a1_yadd;
5829                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5830                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5831                 }
5832                 a1_x+=a1_step_x;
5833                 a1_y+=a1_step_y;
5834                 a2_x+=a2_step_x;
5835                 a2_y+=a2_step_y;
5836         }
5837         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5838         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5839         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5840 }
5841 #endif
5842 #ifndef blitter_code_0x3c01001c
5843 #define blitter_code_0x3c01001c
5844 void blitter_0x3c01001c(void)
5845 {
5846         while (outer_loop--)
5847         {
5848                 inner_loop=n_pixels;
5849                 while (inner_loop--)
5850                 {
5851                         uint32 srcdata   = 0;
5852                         uint32 srczdata  = 0;
5853                         uint32 dstdata   = 0;
5854                         uint32 dstzdata  = 0;
5855                         uint32 writedata = 0;
5856                         uint32 inhibit   = 0;
5857                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
5858                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
5859                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
5860                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
5861                         if (!inhibit)
5862                         {
5863                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
5864                         } else { srczdata=dstzdata; writedata=dstdata; }
5865                         WRITE_PIXEL_16(a1, writedata);
5866                         a1_x += a1_xadd;
5867                         a1_y += a1_yadd;
5868                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5869                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5870                 }
5871                 a1_x+=a1_step_x;
5872                 a1_y+=a1_step_y;
5873                 a2_x+=a2_step_x;
5874                 a2_y+=a2_step_y;
5875         }
5876         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5877         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5878         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5879 }
5880 #endif
5881 #ifndef blitter_code_0x2c010218
5882 #define blitter_code_0x2c010218
5883 void blitter_0x2c010218(void)
5884 {
5885         while (outer_loop--)
5886         {
5887                 inner_loop=n_pixels;
5888                 while (inner_loop--)
5889                 {
5890                         uint32 srcdata   = 0;
5891                         uint32 srczdata  = 0;
5892                         uint32 dstdata   = 0;
5893                         uint32 dstzdata  = 0;
5894                         uint32 writedata = 0;
5895                         uint32 inhibit   = 0;
5896                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
5897                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
5898                         dstdata = READ_PIXEL_1(a1);
5899                         dstzdata = READ_RDATA_1(DSTZ, a1, a1_phrase_mode);
5900                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
5901                         if (!inhibit)
5902                         {
5903                                 writedata= READ_RDATA_1(PATTERNDATA, a1, a1_phrase_mode);
5904                         } else { srczdata=dstzdata; writedata=dstdata; }
5905                         if (!inhibit)
5906                         {
5907                                 WRITE_PIXEL_1(a1, writedata);
5908                         }
5909                         a1_x += a1_xadd;
5910                         a1_y += a1_yadd;
5911                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5912                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5913                 }
5914                 a1_x+=a1_step_x;
5915                 a1_y+=a1_step_y;
5916                 a2_x+=a2_step_x;
5917                 a2_y+=a2_step_y;
5918         }
5919         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5920         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5921         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5922 }
5923 #endif
5924 #ifndef blitter_code_0x3050021b
5925 #define blitter_code_0x3050021b
5926 void blitter_0x3050021b(void)
5927 {
5928         while (outer_loop--)
5929         {
5930                 inner_loop=n_pixels;
5931                 while (inner_loop--)
5932                 {
5933                         uint32 srcdata   = 0;
5934                         uint32 srczdata  = 0;
5935                         uint32 dstdata   = 0;
5936                         uint32 dstzdata  = 0;
5937                         uint32 writedata = 0;
5938                         uint32 inhibit   = 0;
5939                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
5940                         dstdata = READ_PIXEL_8(a1);
5941                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
5942                         if (!inhibit)
5943                         {
5944                                 writedata |= ~srcdata & ~dstdata;
5945                                 writedata |= srcdata  & ~dstdata;
5946                         } else { srczdata=dstzdata; writedata=dstdata; }
5947                         WRITE_PIXEL_8(a1, writedata);
5948                         a1_x += a1_xadd;
5949                         a1_y += a1_yadd;
5950                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5951                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5952                 }
5953                 a1_x+=a1_step_x;
5954                 a1_y+=a1_step_y;
5955                 a2_x+=a2_step_x;
5956                 a2_y+=a2_step_y;
5957         }
5958         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5959         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5960         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5961 }
5962 #endif
5963 #ifndef blitter_code_0x34c10004
5964 #define blitter_code_0x34c10004
5965 void blitter_0x34c10004(void)
5966 {
5967         while (outer_loop--)
5968         {
5969                 inner_loop=n_pixels;
5970                 while (inner_loop--)
5971                 {
5972                         uint32 srcdata   = 0;
5973                         uint32 srczdata  = 0;
5974                         uint32 dstdata   = 0;
5975                         uint32 dstzdata  = 0;
5976                         uint32 writedata = 0;
5977                         uint32 inhibit   = 0;
5978                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
5979                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
5980                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
5981                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
5982                         WRITE_PIXEL_16(a1, writedata);
5983                         a1_x += a1_xadd;
5984                         a1_y += a1_yadd;
5985                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
5986                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
5987                 }
5988                 a1_x+=a1_step_x;
5989                 a1_y+=a1_step_y;
5990                 a2_x+=a2_step_x;
5991                 a2_y+=a2_step_y;
5992         }
5993         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
5994         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
5995         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
5996 }
5997 #endif
5998 #ifndef blitter_code_0x05010218
5999 #define blitter_code_0x05010218
6000 void blitter_0x05010218(void)
6001 {
6002         while (outer_loop--)
6003         {
6004                 inner_loop=n_pixels;
6005                 while (inner_loop--)
6006                 {
6007                         uint32 srcdata   = 0;
6008                         uint32 srczdata  = 0;
6009                         uint32 dstdata   = 0;
6010                         uint32 dstzdata  = 0;
6011                         uint32 writedata = 0;
6012                         uint32 inhibit   = 0;
6013                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
6014                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
6015                         dstdata = READ_PIXEL_1(a1);
6016                         dstzdata = READ_RDATA_1(DSTZ, a1, a1_phrase_mode);
6017                                 writedata= READ_RDATA_1(PATTERNDATA, a1, a1_phrase_mode);
6018                         WRITE_PIXEL_1(a1, writedata);
6019                         a1_x += a1_xadd;
6020                         a1_y += a1_yadd;
6021                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6022                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6023                 }
6024                 a1_x+=a1_step_x;
6025                 a1_y+=a1_step_y;
6026                 a2_x+=a2_step_x;
6027                 a2_y+=a2_step_y;
6028         }
6029         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6030         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6031         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6032 }
6033 #endif
6034 #ifndef blitter_code_0x30020224
6035 #define blitter_code_0x30020224
6036 void blitter_0x30020224(void)
6037 {
6038         while (outer_loop--)
6039         {
6040                 inner_loop=n_pixels;
6041                 while (inner_loop--)
6042                 {
6043                         uint32 srcdata   = 0;
6044                         uint32 srczdata  = 0;
6045                         uint32 dstdata   = 0;
6046                         uint32 dstzdata  = 0;
6047                         uint32 writedata = 0;
6048                         uint32 inhibit   = 0;
6049                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
6050                         dstdata = READ_PIXEL_16(a1);
6051                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
6052                                 writedata = (srcdata & 0xff) + (dstdata & 0xff);
6053                                 if (writedata > 0xff) writedata = 0xff;
6054                                 writedata |= (srcdata & 0xf00) + (dstdata & 0xf00);
6055                                 if (writedata > 0xfff) writedata = 0xfff;
6056                                 writedata |= (srcdata & 0xf000) + (dstdata & 0xf000);
6057                         WRITE_PIXEL_16(a1, writedata);
6058                         a1_x += a1_xadd;
6059                         a1_y += a1_yadd;
6060                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6061                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6062                 }
6063                 a1_x+=a1_step_x;
6064                 a1_y+=a1_step_y;
6065                 a2_x+=a2_step_x;
6066                 a2_y+=a2_step_y;
6067         }
6068         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6069         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6070         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6071 }
6072 #endif
6073 #ifndef blitter_code_0x24c1001b
6074 #define blitter_code_0x24c1001b
6075 void blitter_0x24c1001b(void)
6076 {
6077         while (outer_loop--)
6078         {
6079                 inner_loop=n_pixels;
6080                 while (inner_loop--)
6081                 {
6082                         uint32 srcdata   = 0;
6083                         uint32 srczdata  = 0;
6084                         uint32 dstdata   = 0;
6085                         uint32 dstzdata  = 0;
6086                         uint32 writedata = 0;
6087                         uint32 inhibit   = 0;
6088                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
6089                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
6090                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
6091                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
6092                                 WRITE_PIXEL_8(a1, writedata);
6093                         a1_x += a1_xadd;
6094                         a1_y += a1_yadd;
6095                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6096                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6097                 }
6098                 a1_x+=a1_step_x;
6099                 a1_y+=a1_step_y;
6100                 a2_x+=a2_step_x;
6101                 a2_y+=a2_step_y;
6102         }
6103         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6104         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6105         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6106 }
6107 #endif
6108 #ifndef blitter_code_0x0501021b
6109 #define blitter_code_0x0501021b
6110 void blitter_0x0501021b(void)
6111 {
6112         while (outer_loop--)
6113         {
6114                 inner_loop=n_pixels;
6115                 while (inner_loop--)
6116                 {
6117                         uint32 srcdata   = 0;
6118                         uint32 srczdata  = 0;
6119                         uint32 dstdata   = 0;
6120                         uint32 dstzdata  = 0;
6121                         uint32 writedata = 0;
6122                         uint32 inhibit   = 0;
6123                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
6124                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
6125                         dstdata = READ_PIXEL_8(a1);
6126                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
6127                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
6128                         WRITE_PIXEL_8(a1, writedata);
6129                         a1_x += a1_xadd;
6130                         a1_y += a1_yadd;
6131                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6132                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6133                 }
6134                 a1_x+=a1_step_x;
6135                 a1_y+=a1_step_y;
6136                 a2_x+=a2_step_x;
6137                 a2_y+=a2_step_y;
6138         }
6139         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6140         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6141         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6142 }
6143 #endif
6144 #ifndef blitter_code_0x04c1001b
6145 #define blitter_code_0x04c1001b
6146 void blitter_0x04c1001b(void)
6147 {
6148         while (outer_loop--)
6149         {
6150                 inner_loop=n_pixels;
6151                 while (inner_loop--)
6152                 {
6153                         uint32 srcdata   = 0;
6154                         uint32 srczdata  = 0;
6155                         uint32 dstdata   = 0;
6156                         uint32 dstzdata  = 0;
6157                         uint32 writedata = 0;
6158                         uint32 inhibit   = 0;
6159                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
6160                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
6161                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
6162                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
6163                                 WRITE_PIXEL_8(a1, writedata);
6164                         a1_x += a1_xadd;
6165                         a1_y += a1_yadd;
6166                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6167                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6168                 }
6169                 a1_x+=a1_step_x;
6170                 a1_y+=a1_step_y;
6171                 a2_x+=a2_step_x;
6172                 a2_y+=a2_step_y;
6173         }
6174         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6175         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6176         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6177 }
6178 #endif
6179 #ifndef blitter_code_0x24c10023
6180 #define blitter_code_0x24c10023
6181 void blitter_0x24c10023(void)
6182 {
6183         while (outer_loop--)
6184         {
6185                 inner_loop=n_pixels;
6186                 while (inner_loop--)
6187                 {
6188                         uint32 srcdata   = 0;
6189                         uint32 srczdata  = 0;
6190                         uint32 dstdata   = 0;
6191                         uint32 dstzdata  = 0;
6192                         uint32 writedata = 0;
6193                         uint32 inhibit   = 0;
6194                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
6195                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
6196                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
6197                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
6198                                 WRITE_PIXEL_8(a1, writedata);
6199                         a1_x += a1_xadd;
6200                         a1_y += a1_yadd;
6201                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6202                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6203                 }
6204                 a1_x+=a1_step_x;
6205                 a1_y+=a1_step_y;
6206                 a2_x+=a2_step_x;
6207                 a2_y+=a2_step_y;
6208         }
6209         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6210         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6211         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6212 }
6213 #endif
6214 #ifndef blitter_code_0x01c040a4
6215 #define blitter_code_0x01c040a4
6216 void blitter_0x01c040a4(void)
6217 {
6218         while (outer_loop--)
6219         {
6220                 inner_loop=n_pixels;
6221                 while (inner_loop--)
6222                 {
6223                         uint32 srcdata   = 0;
6224                         uint32 srczdata  = 0;
6225                         uint32 dstdata   = 0;
6226                         uint32 dstzdata  = 0;
6227                         uint32 writedata = 0;
6228                         uint32 inhibit   = 0;
6229                         srcdata = READ_PIXEL_16(a2);
6230                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
6231                         if (srcdata == READ_RDATA_16(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
6232                         if (!inhibit)
6233                         {
6234                                 writedata |= srcdata  & ~dstdata;
6235                                 writedata |= srcdata  & dstdata;
6236                         } else { srczdata=dstzdata; writedata=dstdata; }
6237                         WRITE_PIXEL_16(a1, writedata);
6238                         a1_x += a1_xadd;
6239                         a1_y += a1_yadd;
6240                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6241                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6242                 }
6243                 a1_x+=a1_step_x;
6244                 a1_y+=a1_step_y;
6245                 a2_x+=a2_step_x;
6246                 a2_y+=a2_step_y;
6247         }
6248         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6249         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6250         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6251 }
6252 #endif
6253 #ifndef blitter_code_0x04c10024
6254 #define blitter_code_0x04c10024
6255 void blitter_0x04c10024(void)
6256 {
6257         while (outer_loop--)
6258         {
6259                 inner_loop=n_pixels;
6260                 while (inner_loop--)
6261                 {
6262                         uint32 srcdata   = 0;
6263                         uint32 srczdata  = 0;
6264                         uint32 dstdata   = 0;
6265                         uint32 dstzdata  = 0;
6266                         uint32 writedata = 0;
6267                         uint32 inhibit   = 0;
6268                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
6269                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
6270                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
6271                         if (!inhibit)
6272                         {
6273                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
6274                         } else { srczdata=dstzdata; writedata=dstdata; }
6275                         if (!inhibit)
6276                         {
6277                                 WRITE_PIXEL_16(a1, writedata);
6278                         }
6279                         a1_x += a1_xadd;
6280                         a1_y += a1_yadd;
6281                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6282                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6283                 }
6284                 a1_x+=a1_step_x;
6285                 a1_y+=a1_step_y;
6286                 a2_x+=a2_step_x;
6287                 a2_y+=a2_step_y;
6288         }
6289         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6290         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6291         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6292 }
6293 #endif
6294 #ifndef blitter_code_0x0501021c
6295 #define blitter_code_0x0501021c
6296 void blitter_0x0501021c(void)
6297 {
6298         while (outer_loop--)
6299         {
6300                 inner_loop=n_pixels;
6301                 while (inner_loop--)
6302                 {
6303                         uint32 srcdata   = 0;
6304                         uint32 srczdata  = 0;
6305                         uint32 dstdata   = 0;
6306                         uint32 dstzdata  = 0;
6307                         uint32 writedata = 0;
6308                         uint32 inhibit   = 0;
6309                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
6310                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
6311                         dstdata = READ_PIXEL_16(a1);
6312                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
6313                         if (!inhibit)
6314                         {
6315                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
6316                         } else { srczdata=dstzdata; writedata=dstdata; }
6317                         WRITE_PIXEL_16(a1, writedata);
6318                         a1_x += a1_xadd;
6319                         a1_y += a1_yadd;
6320                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6321                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6322                 }
6323                 a1_x+=a1_step_x;
6324                 a1_y+=a1_step_y;
6325                 a2_x+=a2_step_x;
6326                 a2_y+=a2_step_y;
6327         }
6328         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6329         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6330         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6331 }
6332 #endif
6333 #ifndef blitter_code_0x30e00224
6334 #define blitter_code_0x30e00224
6335 void blitter_0x30e00224(void)
6336 {
6337         while (outer_loop--)
6338         {
6339                 inner_loop=n_pixels;
6340                 while (inner_loop--)
6341                 {
6342                         uint32 srcdata   = 0;
6343                         uint32 srczdata  = 0;
6344                         uint32 dstdata   = 0;
6345                         uint32 dstzdata  = 0;
6346                         uint32 writedata = 0;
6347                         uint32 inhibit   = 0;
6348                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
6349                         dstdata = READ_PIXEL_16(a1);
6350                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
6351                         if (!inhibit)
6352                         {
6353                                 writedata |= ~srcdata & dstdata;
6354                                 writedata |= srcdata  & ~dstdata;
6355                                 writedata |= srcdata  & dstdata;
6356                         } else { srczdata=dstzdata; writedata=dstdata; }
6357                         WRITE_PIXEL_16(a1, writedata);
6358                         a1_x += a1_xadd;
6359                         a1_y += a1_yadd;
6360                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6361                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6362                 }
6363                 a1_x+=a1_step_x;
6364                 a1_y+=a1_step_y;
6365                 a2_x+=a2_step_x;
6366                 a2_y+=a2_step_y;
6367         }
6368         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6369         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6370         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6371 }
6372 #endif
6373 #ifndef blitter_code_0x2401002d
6374 #define blitter_code_0x2401002d
6375 void blitter_0x2401002d(void)
6376 {
6377         while (outer_loop--)
6378         {
6379                 inner_loop=n_pixels;
6380                 while (inner_loop--)
6381                 {
6382                         uint32 srcdata   = 0;
6383                         uint32 srczdata  = 0;
6384                         uint32 dstdata   = 0;
6385                         uint32 dstzdata  = 0;
6386                         uint32 writedata = 0;
6387                         uint32 inhibit   = 0;
6388                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
6389                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
6390                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
6391                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
6392                                 WRITE_PIXEL_32(a1, writedata);
6393                         a1_x += a1_xadd;
6394                         a1_y += a1_yadd;
6395                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6396                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6397                 }
6398                 a1_x+=a1_step_x;
6399                 a1_y+=a1_step_y;
6400                 a2_x+=a2_step_x;
6401                 a2_y+=a2_step_y;
6402         }
6403         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6404         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6405         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6406 }
6407 #endif
6408 #ifndef blitter_code_0x2401002c
6409 #define blitter_code_0x2401002c
6410 void blitter_0x2401002c(void)
6411 {
6412         while (outer_loop--)
6413         {
6414                 inner_loop=n_pixels;
6415                 while (inner_loop--)
6416                 {
6417                         uint32 srcdata   = 0;
6418                         uint32 srczdata  = 0;
6419                         uint32 dstdata   = 0;
6420                         uint32 dstzdata  = 0;
6421                         uint32 writedata = 0;
6422                         uint32 inhibit   = 0;
6423                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
6424                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
6425                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
6426                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
6427                                 WRITE_PIXEL_16(a1, writedata);
6428                         a1_x += a1_xadd;
6429                         a1_y += a1_yadd;
6430                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6431                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6432                 }
6433                 a1_x+=a1_step_x;
6434                 a1_y+=a1_step_y;
6435                 a2_x+=a2_step_x;
6436                 a2_y+=a2_step_y;
6437         }
6438         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6439         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6440         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6441 }
6442 #endif
6443 #ifndef blitter_code_0x24010005
6444 #define blitter_code_0x24010005
6445 void blitter_0x24010005(void)
6446 {
6447         while (outer_loop--)
6448         {
6449                 inner_loop=n_pixels;
6450                 while (inner_loop--)
6451                 {
6452                         uint32 srcdata   = 0;
6453                         uint32 srczdata  = 0;
6454                         uint32 dstdata   = 0;
6455                         uint32 dstzdata  = 0;
6456                         uint32 writedata = 0;
6457                         uint32 inhibit   = 0;
6458                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
6459                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
6460                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
6461                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
6462                                 WRITE_PIXEL_32(a1, writedata);
6463                         a1_x += a1_xadd;
6464                         a1_y += a1_yadd;
6465                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6466                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6467                 }
6468                 a1_x+=a1_step_x;
6469                 a1_y+=a1_step_y;
6470                 a2_x+=a2_step_x;
6471                 a2_y+=a2_step_y;
6472         }
6473         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6474         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6475         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6476 }
6477 #endif
6478 #ifndef blitter_code_0x04010220
6479 #define blitter_code_0x04010220
6480 void blitter_0x04010220(void)
6481 {
6482         while (outer_loop--)
6483         {
6484                 inner_loop=n_pixels;
6485                 while (inner_loop--)
6486                 {
6487                         uint32 srcdata   = 0;
6488                         uint32 srczdata  = 0;
6489                         uint32 dstdata   = 0;
6490                         uint32 dstzdata  = 0;
6491                         uint32 writedata = 0;
6492                         uint32 inhibit   = 0;
6493                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
6494                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
6495                         dstdata = READ_PIXEL_1(a1);
6496                         dstzdata = READ_RDATA_1(DSTZ, a1, a1_phrase_mode);
6497                                 writedata= READ_RDATA_1(PATTERNDATA, a1, a1_phrase_mode);
6498                                 WRITE_PIXEL_1(a1, writedata);
6499                         a1_x += a1_xadd;
6500                         a1_y += a1_yadd;
6501                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6502                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6503                 }
6504                 a1_x+=a1_step_x;
6505                 a1_y+=a1_step_y;
6506                 a2_x+=a2_step_x;
6507                 a2_y+=a2_step_y;
6508         }
6509         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6510         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6511         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6512 }
6513 #endif
6514 #ifndef blitter_code_0x00c000ed
6515 #define blitter_code_0x00c000ed
6516 void blitter_0x00c000ed(void)
6517 {
6518         while (outer_loop--)
6519         {
6520                 inner_loop=n_pixels;
6521                 while (inner_loop--)
6522                 {
6523                         uint32 srcdata   = 0;
6524                         uint32 srczdata  = 0;
6525                         uint32 dstdata   = 0;
6526                         uint32 dstzdata  = 0;
6527                         uint32 writedata = 0;
6528                         uint32 inhibit   = 0;
6529                         srcdata = READ_PIXEL_32(a1);
6530                         dstdata = READ_RDATA_32(DSTDATA, a2, a2_phrase_mode);
6531                                 writedata |= srcdata  & ~dstdata;
6532                                 writedata |= srcdata  & dstdata;
6533                                 WRITE_PIXEL_32(a2, writedata);
6534                         a1_x += a1_xadd;
6535                         a1_y += a1_yadd;
6536                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6537                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6538                 }
6539                 a1_x+=a1_step_x;
6540                 a1_y+=a1_step_y;
6541                 a2_x+=a2_step_x;
6542                 a2_y+=a2_step_y;
6543         }
6544         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6545         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6546         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6547 }
6548 #endif
6549 #ifndef blitter_code_0x040e026d
6550 #define blitter_code_0x040e026d
6551 void blitter_0x040e026d(void)
6552 {
6553         while (outer_loop--)
6554         {
6555                 inner_loop=n_pixels;
6556                 while (inner_loop--)
6557                 {
6558                         uint32 srcdata   = 0;
6559                         uint32 srczdata  = 0;
6560                         uint32 dstdata   = 0;
6561                         uint32 dstzdata  = 0;
6562                         uint32 writedata = 0;
6563                         uint32 inhibit   = 0;
6564                         srcdata = READ_RDATA_32(SRCDATA, a1, a1_phrase_mode);
6565                         srczdata = READ_RDATA_32(SRCZINT, a1, a1_phrase_mode);
6566                         dstdata = READ_PIXEL_32(a2);
6567                         dstzdata = READ_RDATA_32(DSTZ, a2, a2_phrase_mode);
6568                                 writedata = (srcdata & 0xff) + (dstdata & 0xff);
6569                                 writedata |= (srcdata & 0xf00) + (dstdata & 0xf00);
6570                                 writedata |= (srcdata & 0xf000) + (dstdata & 0xf000);
6571                                 WRITE_PIXEL_32(a2, writedata);
6572                         a1_x += a1_xadd;
6573                         a1_y += a1_yadd;
6574                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6575                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6576                 }
6577                 a1_x+=a1_step_x;
6578                 a1_y+=a1_step_y;
6579                 a2_x+=a2_step_x;
6580                 a2_y+=a2_step_y;
6581         }
6582         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6583         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6584         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6585 }
6586 #endif
6587 #ifndef blitter_code_0x0c01002c
6588 #define blitter_code_0x0c01002c
6589 void blitter_0x0c01002c(void)
6590 {
6591 //      fprintf(log_get(),"blitter_0x0c01002c: 0x%.8x 0x%.8x 0x%.8x 0x%.8x cpu %i pc=0x%.8x\n",
6592 //                                         gd_i[0],gd_c[0],gd_ia,gd_ca,jaguar_cpu_in_exec,gpu_read_pc());
6593
6594         while (outer_loop--)
6595         {
6596                 inner_loop=n_pixels;
6597                 while (inner_loop--)
6598                 {
6599                         uint32 dstdata   = 0;
6600                         uint32 writedata = 0;
6601                         uint32 inhibit   = 0;
6602                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
6603                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
6604                         if (!inhibit)
6605                         {
6606                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
6607                         }
6608                         else
6609                         {
6610                                 writedata=dstdata;
6611                         }
6612                         if (!inhibit)
6613                         {
6614                                 WRITE_PIXEL_16(a1, writedata);
6615                         }
6616                         a1_x += a1_xadd;
6617                         a1_y += a1_yadd;
6618                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6619                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6620                         gd_i[colour_index] += gd_ia;
6621                         gd_c[colour_index] += gd_ca;
6622                 }
6623                 a1_x+=a1_step_x;
6624                 a1_y+=a1_step_y;
6625                 a2_x+=a2_step_x;
6626                 a2_y+=a2_step_y;
6627         }
6628         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6629         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6630         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6631 }
6632 #endif
6633 #ifndef blitter_code_0x040e026c
6634 #define blitter_code_0x040e026c
6635 void blitter_0x040e026c(void)
6636 {
6637         while (outer_loop--)
6638         {
6639                 inner_loop=n_pixels;
6640                 while (inner_loop--)
6641                 {
6642                         uint32 srcdata   = 0;
6643                         uint32 srczdata  = 0;
6644                         uint32 dstdata   = 0;
6645                         uint32 dstzdata  = 0;
6646                         uint32 writedata = 0;
6647                         uint32 inhibit   = 0;
6648                         srcdata = READ_RDATA_32(SRCDATA, a1, a1_phrase_mode);
6649                         srczdata = READ_RDATA_32(SRCZINT, a1, a1_phrase_mode);
6650                         dstdata = READ_PIXEL_32(a2);
6651                         dstzdata = READ_RDATA_32(DSTZ, a2, a2_phrase_mode);
6652                         if (!inhibit)
6653                         {
6654                                 writedata = (srcdata & 0xff) + (dstdata & 0xff);
6655                                 writedata |= (srcdata & 0xf00) + (dstdata & 0xf00);
6656                                 writedata |= (srcdata & 0xf000) + (dstdata & 0xf000);
6657                         } else { srczdata=dstzdata; writedata=dstdata; }
6658                         if (!inhibit)
6659                         {
6660                                 WRITE_PIXEL_32(a2, writedata);
6661                         }
6662                         a1_x += a1_xadd;
6663                         a1_y += a1_yadd;
6664                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6665                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6666                 }
6667                 a1_x+=a1_step_x;
6668                 a1_y+=a1_step_y;
6669                 a2_x+=a2_step_x;
6670                 a2_y+=a2_step_y;
6671         }
6672         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6673         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6674         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6675 }
6676 #endif
6677 #ifndef blitter_code_0x00c04280
6678 #define blitter_code_0x00c04280
6679 void blitter_0x00c04280(void)
6680 {
6681         while (outer_loop--)
6682         {
6683                 inner_loop=n_pixels;
6684                 while (inner_loop--)
6685                 {
6686                         uint32 srcdata   = 0;
6687                         uint32 srczdata  = 0;
6688                         uint32 dstdata   = 0;
6689                         uint32 dstzdata  = 0;
6690                         uint32 writedata = 0;
6691                         uint32 inhibit   = 0;
6692                         srcdata = READ_PIXEL_1(a2);
6693                         dstdata = READ_PIXEL_1(a1);
6694                         dstzdata = READ_RDATA_1(DSTZ, a1, a1_phrase_mode);
6695                         if (srcdata == READ_RDATA_1(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
6696                         if (!inhibit)
6697                         {
6698                                 writedata |= srcdata  & ~dstdata;
6699                                 writedata |= srcdata  & dstdata;
6700                         } else { srczdata=dstzdata; writedata=dstdata; }
6701                         if (!inhibit)
6702                         {
6703                                 WRITE_PIXEL_1(a1, writedata);
6704                         }
6705                         a1_x += a1_xadd;
6706                         a1_y += a1_yadd;
6707                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6708                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6709                 }
6710                 a1_x+=a1_step_x;
6711                 a1_y+=a1_step_y;
6712                 a2_x+=a2_step_x;
6713                 a2_y+=a2_step_y;
6714         }
6715         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6716         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6717         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6718 }
6719 #endif
6720 #ifndef blitter_code_0x04010200
6721 #define blitter_code_0x04010200
6722 void blitter_0x04010200(void)
6723 {
6724         while (outer_loop--)
6725         {
6726                 inner_loop=n_pixels;
6727                 while (inner_loop--)
6728                 {
6729                         uint32 srcdata   = 0;
6730                         uint32 srczdata  = 0;
6731                         uint32 dstdata   = 0;
6732                         uint32 dstzdata  = 0;
6733                         uint32 writedata = 0;
6734                         uint32 inhibit   = 0;
6735                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
6736                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
6737                         dstdata = READ_PIXEL_1(a1);
6738                         dstzdata = READ_RDATA_1(DSTZ, a1, a1_phrase_mode);
6739                         if (!inhibit)
6740                         {
6741                                 writedata= READ_RDATA_1(PATTERNDATA, a1, a1_phrase_mode);
6742                         } else { srczdata=dstzdata; writedata=dstdata; }
6743                         if (!inhibit)
6744                         {
6745                                 WRITE_PIXEL_1(a1, writedata);
6746                         }
6747                         a1_x += a1_xadd;
6748                         a1_y += a1_yadd;
6749                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6750                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6751                 }
6752                 a1_x+=a1_step_x;
6753                 a1_y+=a1_step_y;
6754                 a2_x+=a2_step_x;
6755                 a2_y+=a2_step_y;
6756         }
6757         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6758         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6759         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6760 }
6761 #endif
6762 #ifndef blitter_code_0x00600280
6763 #define blitter_code_0x00600280
6764 void blitter_0x00600280(void)
6765 {
6766         while (outer_loop--)
6767         {
6768                 inner_loop=n_pixels;
6769                 while (inner_loop--)
6770                 {
6771                         uint32 srcdata   = 0;
6772                         uint32 srczdata  = 0;
6773                         uint32 dstdata   = 0;
6774                         uint32 dstzdata  = 0;
6775                         uint32 writedata = 0;
6776                         uint32 inhibit   = 0;
6777                         srcdata = READ_PIXEL_1(a2);
6778                         dstdata = READ_PIXEL_1(a1);
6779                         dstzdata = READ_RDATA_1(DSTZ, a1, a1_phrase_mode);
6780                         if (!inhibit)
6781                         {
6782                                 writedata |= ~srcdata & dstdata;
6783                                 writedata |= srcdata  & ~dstdata;
6784                         } else { srczdata=dstzdata; writedata=dstdata; }
6785                         if (!inhibit)
6786                         {
6787                                 WRITE_PIXEL_1(a1, writedata);
6788                         }
6789                         a1_x += a1_xadd;
6790                         a1_y += a1_yadd;
6791                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6792                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6793                 }
6794                 a1_x+=a1_step_x;
6795                 a1_y+=a1_step_y;
6796                 a2_x+=a2_step_x;
6797                 a2_y+=a2_step_y;
6798         }
6799         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6800         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6801         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6802 }
6803 #endif
6804 #ifndef blitter_code_0x04010005
6805 #define blitter_code_0x04010005
6806 void blitter_0x04010005(void)
6807 {
6808         while (outer_loop--)
6809         {
6810                 inner_loop=n_pixels;
6811                 while (inner_loop--)
6812                 {
6813                         uint32 srcdata   = 0;
6814                         uint32 srczdata  = 0;
6815                         uint32 dstdata   = 0;
6816                         uint32 dstzdata  = 0;
6817                         uint32 writedata = 0;
6818                         uint32 inhibit   = 0;
6819                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
6820                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
6821                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
6822                         if (!inhibit)
6823                         {
6824                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
6825                         } else { srczdata=dstzdata; writedata=dstdata; }
6826                         if (!inhibit)
6827                         {
6828                                 WRITE_PIXEL_32(a1, writedata);
6829                         }
6830                         a1_x += a1_xadd;
6831                         a1_y += a1_yadd;
6832                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6833                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6834                 }
6835                 a1_x+=a1_step_x;
6836                 a1_y+=a1_step_y;
6837                 a2_x+=a2_step_x;
6838                 a2_y+=a2_step_y;
6839         }
6840         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6841         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6842         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6843 }
6844 #endif
6845 #ifndef blitter_code_0x0401002c
6846 #define blitter_code_0x0401002c
6847 void blitter_0x0401002c(void)
6848 {
6849         while (outer_loop--)
6850         {
6851                 inner_loop=n_pixels;
6852                 while (inner_loop--)
6853                 {
6854                         uint32 srcdata   = 0;
6855                         uint32 srczdata  = 0;
6856                         uint32 dstdata   = 0;
6857                         uint32 dstzdata  = 0;
6858                         uint32 writedata = 0;
6859                         uint32 inhibit   = 0;
6860                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
6861                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
6862                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
6863                         if (!inhibit)
6864                         {
6865                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
6866                         } else { srczdata=dstzdata; writedata=dstdata; }
6867                         if (!inhibit)
6868                         {
6869                                 WRITE_PIXEL_16(a1, writedata);
6870                         }
6871                         a1_x += a1_xadd;
6872                         a1_y += a1_yadd;
6873                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6874                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6875                 }
6876                 a1_x+=a1_step_x;
6877                 a1_y+=a1_step_y;
6878                 a2_x+=a2_step_x;
6879                 a2_y+=a2_step_y;
6880         }
6881         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6882         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6883         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6884 }
6885 #endif
6886 #ifndef blitter_code_0x30c000db
6887 #define blitter_code_0x30c000db
6888 void blitter_0x30c000db(void)
6889 {
6890         while (outer_loop--)
6891         {
6892                 inner_loop=n_pixels;
6893                 while (inner_loop--)
6894                 {
6895                         uint32 srcdata   = 0;
6896                         uint32 srczdata  = 0;
6897                         uint32 dstdata   = 0;
6898                         uint32 dstzdata  = 0;
6899                         uint32 writedata = 0;
6900                         uint32 inhibit   = 0;
6901                         srcdata = READ_PIXEL_8(a1);
6902                         dstdata = READ_RDATA_8(DSTDATA, a2, a2_phrase_mode);
6903                                 writedata |= srcdata  & ~dstdata;
6904                                 writedata |= srcdata  & dstdata;
6905                         WRITE_PIXEL_8(a2, writedata);
6906                         a1_x += a1_xadd;
6907                         a1_y += a1_yadd;
6908                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6909                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6910                 }
6911                 a1_x+=a1_step_x;
6912                 a1_y+=a1_step_y;
6913                 a2_x+=a2_step_x;
6914                 a2_y+=a2_step_y;
6915         }
6916         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6917         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6918         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6919 }
6920 #endif
6921 #ifndef blitter_code_0x30c002ad
6922 #define blitter_code_0x30c002ad
6923 void blitter_0x30c002ad(void)
6924 {
6925         while (outer_loop--)
6926         {
6927                 inner_loop=n_pixels;
6928                 while (inner_loop--)
6929                 {
6930                         uint32 srcdata   = 0;
6931                         uint32 srczdata  = 0;
6932                         uint32 dstdata   = 0;
6933                         uint32 dstzdata  = 0;
6934                         uint32 writedata = 0;
6935                         uint32 inhibit   = 0;
6936                         srcdata = READ_PIXEL_32(a2);
6937                         dstdata = READ_PIXEL_32(a1);
6938                         dstzdata = READ_RDATA_32(DSTZ, a1, a1_phrase_mode);
6939                                 writedata |= srcdata  & ~dstdata;
6940                                 writedata |= srcdata  & dstdata;
6941                         WRITE_PIXEL_32(a1, writedata);
6942                         a1_x += a1_xadd;
6943                         a1_y += a1_yadd;
6944                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6945                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6946                 }
6947                 a1_x+=a1_step_x;
6948                 a1_y+=a1_step_y;
6949                 a2_x+=a2_step_x;
6950                 a2_y+=a2_step_y;
6951         }
6952         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6953         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6954         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6955 }
6956 #endif
6957 #ifndef blitter_code_0x3401009b
6958 #define blitter_code_0x3401009b
6959 void blitter_0x3401009b(void)
6960 {
6961         while (outer_loop--)
6962         {
6963                 inner_loop=n_pixels;
6964                 while (inner_loop--)
6965                 {
6966                         uint32 srcdata   = 0;
6967                         uint32 srczdata  = 0;
6968                         uint32 dstdata   = 0;
6969                         uint32 dstzdata  = 0;
6970                         uint32 writedata = 0;
6971                         uint32 inhibit   = 0;
6972                         srcdata = READ_PIXEL_8(a2);
6973                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
6974                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
6975                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
6976                         WRITE_PIXEL_8(a1, writedata);
6977                         a1_x += a1_xadd;
6978                         a1_y += a1_yadd;
6979                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
6980                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
6981                 }
6982                 a1_x+=a1_step_x;
6983                 a1_y+=a1_step_y;
6984                 a2_x+=a2_step_x;
6985                 a2_y+=a2_step_y;
6986         }
6987         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
6988         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
6989         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
6990 }
6991 #endif
6992 #ifndef blitter_code_0x04c1022d
6993 #define blitter_code_0x04c1022d
6994 void blitter_0x04c1022d(void)
6995 {
6996         while (outer_loop--)
6997         {
6998                 inner_loop=n_pixels;
6999                 while (inner_loop--)
7000                 {
7001                         uint32 srcdata   = 0;
7002                         uint32 srczdata  = 0;
7003                         uint32 dstdata   = 0;
7004                         uint32 dstzdata  = 0;
7005                         uint32 writedata = 0;
7006                         uint32 inhibit   = 0;
7007                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
7008                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
7009                         dstdata = READ_PIXEL_32(a1);
7010                         dstzdata = READ_RDATA_32(DSTZ, a1, a1_phrase_mode);
7011                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
7012                                 WRITE_PIXEL_32(a1, writedata);
7013                         a1_x += a1_xadd;
7014                         a1_y += a1_yadd;
7015                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7016                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7017                 }
7018                 a1_x+=a1_step_x;
7019                 a1_y+=a1_step_y;
7020                 a2_x+=a2_step_x;
7021                 a2_y+=a2_step_y;
7022         }
7023         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7024         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7025         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7026 }
7027 #endif
7028 #ifndef blitter_code_0x008002ad
7029 #define blitter_code_0x008002ad
7030 void blitter_0x008002ad(void)
7031 {
7032         while (outer_loop--)
7033         {
7034                 inner_loop=n_pixels;
7035                 while (inner_loop--)
7036                 {
7037                         uint32 srcdata   = 0;
7038                         uint32 srczdata  = 0;
7039                         uint32 dstdata   = 0;
7040                         uint32 dstzdata  = 0;
7041                         uint32 writedata = 0;
7042                         uint32 inhibit   = 0;
7043                         srcdata = READ_PIXEL_32(a2);
7044                         dstdata = READ_PIXEL_32(a1);
7045                         dstzdata = READ_RDATA_32(DSTZ, a1, a1_phrase_mode);
7046                                 writedata |= srcdata  & dstdata;
7047                                 WRITE_PIXEL_32(a1, writedata);
7048                         a1_x += a1_xadd;
7049                         a1_y += a1_yadd;
7050                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7051                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7052                 }
7053                 a1_x+=a1_step_x;
7054                 a1_y+=a1_step_y;
7055                 a2_x+=a2_step_x;
7056                 a2_y+=a2_step_y;
7057         }
7058         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7059         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7060         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7061 }
7062 #endif
7063 #ifndef blitter_code_0x14c1022d
7064 #define blitter_code_0x14c1022d
7065 void blitter_0x14c1022d(void)
7066 {
7067         while (outer_loop--)
7068         {
7069                 inner_loop=n_pixels;
7070                 while (inner_loop--)
7071                 {
7072                         uint32 srcdata   = 0;
7073                         uint32 srczdata  = 0;
7074                         uint32 dstdata   = 0;
7075                         uint32 dstzdata  = 0;
7076                         uint32 writedata = 0;
7077                         uint32 inhibit   = 0;
7078                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
7079                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
7080                         dstdata = READ_PIXEL_32(a1);
7081                         dstzdata = READ_RDATA_32(DSTZ, a1, a1_phrase_mode);
7082                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
7083                         WRITE_PIXEL_32(a1, writedata);
7084                         a1_x += a1_xadd;
7085                         a1_y += a1_yadd;
7086                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7087                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7088                 }
7089                 a1_x+=a1_step_x;
7090                 a1_y+=a1_step_y;
7091                 a2_x+=a2_step_x;
7092                 a2_y+=a2_step_y;
7093         }
7094         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7095         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7096         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7097 }
7098 #endif
7099 #ifndef blitter_code_0x34c1022d
7100 #define blitter_code_0x34c1022d
7101 void blitter_0x34c1022d(void)
7102 {
7103         while (outer_loop--)
7104         {
7105                 inner_loop=n_pixels;
7106                 while (inner_loop--)
7107                 {
7108                         uint32 srcdata   = 0;
7109                         uint32 srczdata  = 0;
7110                         uint32 dstdata   = 0;
7111                         uint32 dstzdata  = 0;
7112                         uint32 writedata = 0;
7113                         uint32 inhibit   = 0;
7114                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
7115                         srczdata = READ_RDATA_32(SRCZINT, a2, a2_phrase_mode);
7116                         dstdata = READ_PIXEL_32(a1);
7117                         dstzdata = READ_RDATA_32(DSTZ, a1, a1_phrase_mode);
7118                                 writedata= READ_RDATA_32(PATTERNDATA, a1, a1_phrase_mode);
7119                         WRITE_PIXEL_32(a1, writedata);
7120                         a1_x += a1_xadd;
7121                         a1_y += a1_yadd;
7122                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7123                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7124                 }
7125                 a1_x+=a1_step_x;
7126                 a1_y+=a1_step_y;
7127                 a2_x+=a2_step_x;
7128                 a2_y+=a2_step_y;
7129         }
7130         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7131         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7132         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7133 }
7134 #endif
7135 #ifndef blitter_code_0x30c0029b
7136 #define blitter_code_0x30c0029b
7137 void blitter_0x30c0029b(void)
7138 {
7139         while (outer_loop--)
7140         {
7141                 inner_loop=n_pixels;
7142                 while (inner_loop--)
7143                 {
7144                         uint32 srcdata   = 0;
7145                         uint32 srczdata  = 0;
7146                         uint32 dstdata   = 0;
7147                         uint32 dstzdata  = 0;
7148                         uint32 writedata = 0;
7149                         uint32 inhibit   = 0;
7150                         srcdata = READ_PIXEL_8(a2);
7151                         dstdata = READ_PIXEL_8(a1);
7152                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
7153                                 writedata |= srcdata  & ~dstdata;
7154                                 writedata |= srcdata  & dstdata;
7155                         WRITE_PIXEL_8(a1, writedata);
7156                         a1_x += a1_xadd;
7157                         a1_y += a1_yadd;
7158                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7159                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7160                 }
7161                 a1_x+=a1_step_x;
7162                 a1_y+=a1_step_y;
7163                 a2_x+=a2_step_x;
7164                 a2_y+=a2_step_y;
7165         }
7166         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7167         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7168         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7169 }
7170 #endif
7171 #ifndef blitter_code_0x24c1021b
7172 #define blitter_code_0x24c1021b
7173 void blitter_0x24c1021b(void)
7174 {
7175         while (outer_loop--)
7176         {
7177                 inner_loop=n_pixels;
7178                 while (inner_loop--)
7179                 {
7180                         uint32 srcdata   = 0;
7181                         uint32 srczdata  = 0;
7182                         uint32 dstdata   = 0;
7183                         uint32 dstzdata  = 0;
7184                         uint32 writedata = 0;
7185                         uint32 inhibit   = 0;
7186                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
7187                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
7188                         dstdata = READ_PIXEL_8(a1);
7189                         dstzdata = READ_RDATA_8(DSTZ, a1, a1_phrase_mode);
7190                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
7191                                 WRITE_PIXEL_8(a1, writedata);
7192                         a1_x += a1_xadd;
7193                         a1_y += a1_yadd;
7194                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7195                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7196                 }
7197                 a1_x+=a1_step_x;
7198                 a1_y+=a1_step_y;
7199                 a2_x+=a2_step_x;
7200                 a2_y+=a2_step_y;
7201         }
7202         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7203         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7204         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7205 }
7206 #endif
7207 #ifndef blitter_code_0x30c042ad
7208 #define blitter_code_0x30c042ad
7209 void blitter_0x30c042ad(void)
7210 {
7211         while (outer_loop--)
7212         {
7213                 inner_loop=n_pixels;
7214                 while (inner_loop--)
7215                 {
7216                         uint32 srcdata   = 0;
7217                         uint32 srczdata  = 0;
7218                         uint32 dstdata   = 0;
7219                         uint32 dstzdata  = 0;
7220                         uint32 writedata = 0;
7221                         uint32 inhibit   = 0;
7222                         srcdata = READ_PIXEL_32(a2);
7223                         dstdata = READ_PIXEL_32(a1);
7224                         dstzdata = READ_RDATA_32(DSTZ, a1, a1_phrase_mode);
7225                         if (srcdata == READ_RDATA_32(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
7226                         if (!inhibit)
7227                         {
7228                                 writedata |= srcdata  & ~dstdata;
7229                                 writedata |= srcdata  & dstdata;
7230                         } else { srczdata=dstzdata; writedata=dstdata; }
7231                         WRITE_PIXEL_32(a1, writedata);
7232                         a1_x += a1_xadd;
7233                         a1_y += a1_yadd;
7234                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7235                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7236                 }
7237                 a1_x+=a1_step_x;
7238                 a1_y+=a1_step_y;
7239                 a2_x+=a2_step_x;
7240                 a2_y+=a2_step_y;
7241         }
7242         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7243         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7244         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7245 }
7246 #endif
7247 #ifndef blitter_code_0x3e01261c
7248 #define blitter_code_0x3e01261c
7249 void blitter_0x3e01261c(void)
7250 {
7251         while (outer_loop--)
7252         {
7253                 inner_loop=n_pixels;
7254                 while (inner_loop--)
7255                 {
7256                         uint32 srcdata   = 0;
7257                         uint32 srczdata  = 0;
7258                         uint32 dstdata   = 0;
7259                         uint32 dstzdata  = 0;
7260                         uint32 writedata = 0;
7261                         uint32 inhibit   = 0;
7262                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
7263                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
7264                         dstdata = READ_PIXEL_16(a1);
7265                         dstzdata = READ_ZDATA_16(a1);
7266                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
7267                         srczdata=z_i[colour_index]>>16;
7268                         if (srczdata >  dstzdata)       inhibit = 1;
7269                         if (!inhibit)
7270                         {
7271                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
7272                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
7273                         } else { srczdata=dstzdata; writedata=dstdata; }
7274                         WRITE_PIXEL_16(a1, writedata);
7275                         WRITE_ZDATA_16(a1, srczdata);
7276                         a1_x += a1_xadd;
7277                         a1_y += a1_yadd;
7278                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7279                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7280                         z_i[colour_index]+=zadd;
7281                         gd_i[colour_index] += gd_ia;
7282                         gd_c[colour_index] += gd_ca;
7283                          colour_index=(colour_index+1)&0x3;
7284                 }
7285                 a1_x+=a1_step_x;
7286                 a1_y+=a1_step_y;
7287                 a2_x+=a2_step_x;
7288                 a2_y+=a2_step_y;
7289         }
7290         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7291         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7292         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7293 }
7294 #endif
7295 #ifndef blitter_code_0x00e00280
7296 #define blitter_code_0x00e00280
7297 void blitter_0x00e00280(void)
7298 {
7299         while (outer_loop--)
7300         {
7301                 inner_loop=n_pixels;
7302                 while (inner_loop--)
7303                 {
7304                         uint32 srcdata   = 0;
7305                         uint32 srczdata  = 0;
7306                         uint32 dstdata   = 0;
7307                         uint32 dstzdata  = 0;
7308                         uint32 writedata = 0;
7309                         uint32 inhibit   = 0;
7310                         srcdata = READ_PIXEL_1(a2);
7311                         dstdata = READ_PIXEL_1(a1);
7312                         dstzdata = READ_RDATA_1(DSTZ, a1, a1_phrase_mode);
7313                                 writedata |= ~srcdata & dstdata;
7314                                 writedata |= srcdata  & ~dstdata;
7315                                 writedata |= srcdata  & dstdata;
7316                                 WRITE_PIXEL_1(a1, writedata);
7317                         a1_x += a1_xadd;
7318                         a1_y += a1_yadd;
7319                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7320                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7321                 }
7322                 a1_x+=a1_step_x;
7323                 a1_y+=a1_step_y;
7324                 a2_x+=a2_step_x;
7325                 a2_y+=a2_step_y;
7326         }
7327         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7328         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7329         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7330 }
7331 #endif
7332 #ifndef blitter_code_0x00e00292
7333 #define blitter_code_0x00e00292
7334 void blitter_0x00e00292(void)
7335 {
7336         while (outer_loop--)
7337         {
7338                 inner_loop=n_pixels;
7339                 while (inner_loop--)
7340                 {
7341                         uint32 srcdata   = 0;
7342                         uint32 srczdata  = 0;
7343                         uint32 dstdata   = 0;
7344                         uint32 dstzdata  = 0;
7345                         uint32 writedata = 0;
7346                         uint32 inhibit   = 0;
7347                         srcdata = READ_PIXEL_4(a2);
7348                         dstdata = READ_PIXEL_4(a1);
7349                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
7350                                 writedata |= ~srcdata & dstdata;
7351                                 writedata |= srcdata  & ~dstdata;
7352                                 writedata |= srcdata  & dstdata;
7353                                 WRITE_PIXEL_4(a1, writedata);
7354                         a1_x += a1_xadd;
7355                         a1_y += a1_yadd;
7356                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7357                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7358                 }
7359                 a1_x+=a1_step_x;
7360                 a1_y+=a1_step_y;
7361                 a2_x+=a2_step_x;
7362                 a2_y+=a2_step_y;
7363         }
7364         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7365         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7366         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7367 }
7368 #endif
7369 #ifndef blitter_code_0x308002a4
7370 #define blitter_code_0x308002a4
7371 void blitter_0x308002a4(void)
7372 {
7373         while (outer_loop--)
7374         {
7375                 inner_loop=n_pixels;
7376                 while (inner_loop--)
7377                 {
7378                         uint32 srcdata   = 0;
7379                         uint32 srczdata  = 0;
7380                         uint32 dstdata   = 0;
7381                         uint32 dstzdata  = 0;
7382                         uint32 writedata = 0;
7383                         uint32 inhibit   = 0;
7384                         srcdata = READ_PIXEL_16(a2);
7385                         dstdata = READ_PIXEL_16(a1);
7386                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
7387                                 writedata |= srcdata  & dstdata;
7388                         WRITE_PIXEL_16(a1, writedata);
7389                         a1_x += a1_xadd;
7390                         a1_y += a1_yadd;
7391                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7392                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7393                 }
7394                 a1_x+=a1_step_x;
7395                 a1_y+=a1_step_y;
7396                 a2_x+=a2_step_x;
7397                 a2_y+=a2_step_y;
7398         }
7399         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7400         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7401         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7402 }
7403 #endif
7404 #ifndef blitter_code_0x00c002a4
7405 #define blitter_code_0x00c002a4
7406 void blitter_0x00c002a4(void)
7407 {
7408         while (outer_loop--)
7409         {
7410                 inner_loop=n_pixels;
7411                 while (inner_loop--)
7412                 {
7413                         uint32 srcdata   = 0;
7414                         uint32 srczdata  = 0;
7415                         uint32 dstdata   = 0;
7416                         uint32 dstzdata  = 0;
7417                         uint32 writedata = 0;
7418                         uint32 inhibit   = 0;
7419                         srcdata = READ_PIXEL_16(a2);
7420                         dstdata = READ_PIXEL_16(a1);
7421                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
7422                                 writedata |= srcdata  & ~dstdata;
7423                                 writedata |= srcdata  & dstdata;
7424                                 WRITE_PIXEL_16(a1, writedata);
7425                         a1_x += a1_xadd;
7426                         a1_y += a1_yadd;
7427                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7428                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7429                 }
7430                 a1_x+=a1_step_x;
7431                 a1_y+=a1_step_y;
7432                 a2_x+=a2_step_x;
7433                 a2_y+=a2_step_y;
7434         }
7435         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7436         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7437         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7438 }
7439 #endif
7440 #ifndef blitter_code_0x01c042a4
7441 #define blitter_code_0x01c042a4
7442 void blitter_0x01c042a4(void)
7443 {
7444         while (outer_loop--)
7445         {
7446                 inner_loop=n_pixels;
7447                 while (inner_loop--)
7448                 {
7449                         uint32 srcdata   = 0;
7450                         uint32 srczdata  = 0;
7451                         uint32 dstdata   = 0;
7452                         uint32 dstzdata  = 0;
7453                         uint32 writedata = 0;
7454                         uint32 inhibit   = 0;
7455                         srcdata = READ_PIXEL_16(a2);
7456                         dstdata = READ_PIXEL_16(a1);
7457                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
7458                         if (srcdata == READ_RDATA_16(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
7459                         if (!inhibit)
7460                         {
7461                                 writedata |= srcdata  & ~dstdata;
7462                                 writedata |= srcdata  & dstdata;
7463                         } else { srczdata=dstzdata; writedata=dstdata; }
7464                         WRITE_PIXEL_16(a1, writedata);
7465                         a1_x += a1_xadd;
7466                         a1_y += a1_yadd;
7467                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7468                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7469                 }
7470                 a1_x+=a1_step_x;
7471                 a1_y+=a1_step_y;
7472                 a2_x+=a2_step_x;
7473                 a2_y+=a2_step_y;
7474         }
7475         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7476         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7477         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7478 }
7479 #endif
7480 #ifndef blitter_code_0x06c066e4
7481 #define blitter_code_0x06c066e4
7482 void blitter_0x06c066e4(void)
7483 {
7484         while (outer_loop--)
7485         {
7486                 inner_loop=n_pixels;
7487                 while (inner_loop--)
7488                 {
7489                         uint32 srcdata   = 0;
7490                         uint32 srczdata  = 0;
7491                         uint32 dstdata   = 0;
7492                         uint32 dstzdata  = 0;
7493                         uint32 writedata = 0;
7494                         uint32 inhibit   = 0;
7495                         srcdata = READ_PIXEL_16(a1);
7496                         srczdata = READ_RDATA_16(SRCZINT, a1, a1_phrase_mode);
7497                         dstdata = READ_PIXEL_16(a2);
7498                         dstzdata = READ_ZDATA_16(a2);
7499                         if (srczdata >  dstzdata)       inhibit = 1;
7500                         if (srcdata == READ_RDATA_16(PATTERNDATA, a1,a1_phrase_mode)) inhibit=1;
7501                         if (!inhibit)
7502                         {
7503                                 writedata |= srcdata  & ~dstdata;
7504                                 writedata |= srcdata  & dstdata;
7505                         } else { srczdata=dstzdata; writedata=dstdata; }
7506                         if (!inhibit)
7507                         {
7508                                 WRITE_PIXEL_16(a2, writedata);
7509                                 WRITE_ZDATA_16(a2, srczdata);
7510                         }
7511                         a1_x += a1_xadd;
7512                         a1_y += a1_yadd;
7513                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7514                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7515                 }
7516                 a1_x+=a1_step_x;
7517                 a1_y+=a1_step_y;
7518                 a2_x+=a2_step_x;
7519                 a2_y+=a2_step_y;
7520         }
7521         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7522         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7523         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7524 }
7525 #endif
7526 #ifndef blitter_code_0x04010222
7527 #define blitter_code_0x04010222
7528 void blitter_0x04010222(void)
7529 {
7530         while (outer_loop--)
7531         {
7532                 inner_loop=n_pixels;
7533                 while (inner_loop--)
7534                 {
7535                         uint32 srcdata   = 0;
7536                         uint32 srczdata  = 0;
7537                         uint32 dstdata   = 0;
7538                         uint32 dstzdata  = 0;
7539                         uint32 writedata = 0;
7540                         uint32 inhibit   = 0;
7541                         srcdata = READ_RDATA_4(SRCDATA, a2, a2_phrase_mode);
7542                         srczdata = READ_RDATA_4(SRCZINT, a2, a2_phrase_mode);
7543                         dstdata = READ_PIXEL_4(a1);
7544                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
7545                                 writedata= READ_RDATA_4(PATTERNDATA, a1, a1_phrase_mode);
7546                                 WRITE_PIXEL_4(a1, writedata);
7547                         a1_x += a1_xadd;
7548                         a1_y += a1_yadd;
7549                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7550                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7551                 }
7552                 a1_x+=a1_step_x;
7553                 a1_y+=a1_step_y;
7554                 a2_x+=a2_step_x;
7555                 a2_y+=a2_step_y;
7556         }
7557         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7558         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7559         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7560 }
7561 #endif
7562 #ifndef blitter_code_0x24010224
7563 #define blitter_code_0x24010224
7564 void blitter_0x24010224(void)
7565 {
7566         while (outer_loop--)
7567         {
7568                 inner_loop=n_pixels;
7569                 while (inner_loop--)
7570                 {
7571                         uint32 srcdata   = 0;
7572                         uint32 srczdata  = 0;
7573                         uint32 dstdata   = 0;
7574                         uint32 dstzdata  = 0;
7575                         uint32 writedata = 0;
7576                         uint32 inhibit   = 0;
7577                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
7578                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
7579                         dstdata = READ_PIXEL_16(a1);
7580                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
7581                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
7582                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
7583                                 WRITE_PIXEL_16(a1, writedata);
7584                         a1_x += a1_xadd;
7585                         a1_y += a1_yadd;
7586                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7587                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7588                         gd_i[colour_index] += gd_ia;
7589                         gd_c[colour_index] += gd_ca;
7590                 }
7591                 a1_x+=a1_step_x;
7592                 a1_y+=a1_step_y;
7593                 a2_x+=a2_step_x;
7594                 a2_y+=a2_step_y;
7595         }
7596         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7597         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7598         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7599 }
7600 #endif
7601 #ifndef blitter_code_0x2000001b
7602 #define blitter_code_0x2000001b
7603 void blitter_0x2000001b(void)
7604 {
7605         while (outer_loop--)
7606         {
7607                 inner_loop=n_pixels;
7608                 while (inner_loop--)
7609                 {
7610                         uint32 srcdata   = 0;
7611                         uint32 srczdata  = 0;
7612                         uint32 dstdata   = 0;
7613                         uint32 dstzdata  = 0;
7614                         uint32 writedata = 0;
7615                         uint32 inhibit   = 0;
7616                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
7617                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
7618                                 WRITE_PIXEL_8(a1, writedata);
7619                         a1_x += a1_xadd;
7620                         a1_y += a1_yadd;
7621                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7622                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7623                 }
7624                 a1_x+=a1_step_x;
7625                 a1_y+=a1_step_y;
7626                 a2_x+=a2_step_x;
7627                 a2_y+=a2_step_y;
7628         }
7629         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7630         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7631         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7632 }
7633 #endif
7634 #ifndef blitter_code_0x3000005b
7635 #define blitter_code_0x3000005b
7636 void blitter_0x3000005b(void)
7637 {
7638         while (outer_loop--)
7639         {
7640                 inner_loop=n_pixels;
7641                 while (inner_loop--)
7642                 {
7643                         uint32 srcdata   = 0;
7644                         uint32 srczdata  = 0;
7645                         uint32 dstdata   = 0;
7646                         uint32 dstzdata  = 0;
7647                         uint32 writedata = 0;
7648                         uint32 inhibit   = 0;
7649                         srcdata = READ_RDATA_8(SRCDATA, a1, a1_phrase_mode);
7650                         dstdata = READ_RDATA_8(DSTDATA, a2, a2_phrase_mode);
7651                         WRITE_PIXEL_8(a2, writedata);
7652                         a1_x += a1_xadd;
7653                         a1_y += a1_yadd;
7654                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7655                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7656                 }
7657                 a1_x+=a1_step_x;
7658                 a1_y+=a1_step_y;
7659                 a2_x+=a2_step_x;
7660                 a2_y+=a2_step_y;
7661         }
7662         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7663         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7664         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7665 }
7666 #endif
7667 #ifndef blitter_code_0x38000100
7668 #define blitter_code_0x38000100
7669 void blitter_0x38000100(void)
7670 {
7671         while (outer_loop--)
7672         {
7673                 inner_loop=n_pixels;
7674                 while (inner_loop--)
7675                 {
7676                         uint32 srcdata   = 0;
7677                         uint32 srczdata  = 0;
7678                         uint32 dstdata   = 0;
7679                         uint32 dstzdata  = 0;
7680                         uint32 writedata = 0;
7681                         uint32 inhibit   = 0;
7682                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
7683                         dstdata = READ_RDATA_1(DSTDATA, a1, a1_phrase_mode);
7684                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
7685                         if (!inhibit)
7686                         {
7687                         } else { srczdata=dstzdata; writedata=dstdata; }
7688                         WRITE_PIXEL_1(a1, writedata);
7689                         a1_x += a1_xadd;
7690                         a1_y += a1_yadd;
7691                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7692                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7693                 }
7694                 a1_x+=a1_step_x;
7695                 a1_y+=a1_step_y;
7696                 a2_x+=a2_step_x;
7697                 a2_y+=a2_step_y;
7698         }
7699         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7700         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7701         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7702 }
7703 #endif
7704 #ifndef blitter_code_0x1c010024
7705 #define blitter_code_0x1c010024
7706 void blitter_0x1c010024(void)
7707 {
7708         while (outer_loop--)
7709         {
7710                 inner_loop=n_pixels;
7711                 while (inner_loop--)
7712                 {
7713                         uint32 srcdata   = 0;
7714                         uint32 srczdata  = 0;
7715                         uint32 dstdata   = 0;
7716                         uint32 dstzdata  = 0;
7717                         uint32 writedata = 0;
7718                         uint32 inhibit   = 0;
7719                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
7720                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
7721                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
7722                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
7723                         if (!inhibit)
7724                         {
7725                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
7726                         } else { srczdata=dstzdata; writedata=dstdata; }
7727                         WRITE_PIXEL_16(a1, writedata);
7728                         a1_x += a1_xadd;
7729                         a1_y += a1_yadd;
7730                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7731                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7732                 }
7733                 a1_x+=a1_step_x;
7734                 a1_y+=a1_step_y;
7735                 a2_x+=a2_step_x;
7736                 a2_y+=a2_step_y;
7737         }
7738         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7739         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7740         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7741 }
7742 #endif
7743 #ifndef blitter_code_0x000242e4
7744 #define blitter_code_0x000242e4
7745 void blitter_0x000242e4(void)
7746 {
7747         while (outer_loop--)
7748         {
7749                 inner_loop=n_pixels;
7750                 while (inner_loop--)
7751                 {
7752                         uint32 srcdata   = 0;
7753                         uint32 srczdata  = 0;
7754                         uint32 dstdata   = 0;
7755                         uint32 dstzdata  = 0;
7756                         uint32 writedata = 0;
7757                         uint32 inhibit   = 0;
7758                         srcdata = READ_PIXEL_16(a1);
7759                         dstdata = READ_PIXEL_16(a2);
7760                         dstzdata = READ_RDATA_16(DSTZ, a2, a2_phrase_mode);
7761                         if (srcdata == READ_RDATA_16(PATTERNDATA, a1,a1_phrase_mode)) inhibit=1;
7762                         if (!inhibit)
7763                         {
7764                                 writedata = (srcdata & 0xff) + (dstdata & 0xff);
7765                                 if (writedata > 0xff) writedata = 0xff;
7766                                 writedata |= (srcdata & 0xf00) + (dstdata & 0xf00);
7767                                 if (writedata > 0xfff) writedata = 0xfff;
7768                                 writedata |= (srcdata & 0xf000) + (dstdata & 0xf000);
7769                         } else { srczdata=dstzdata; writedata=dstdata; }
7770                         if (!inhibit)
7771                         {
7772                                 WRITE_PIXEL_16(a2, writedata);
7773                         }
7774                         a1_x += a1_xadd;
7775                         a1_y += a1_yadd;
7776                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7777                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7778                 }
7779                 a1_x+=a1_step_x;
7780                 a1_y+=a1_step_y;
7781                 a2_x+=a2_step_x;
7782                 a2_y+=a2_step_y;
7783         }
7784         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7785         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7786         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7787 }
7788 #endif
7789 #ifndef blitter_code_0x2c01002c
7790 #define blitter_code_0x2c01002c
7791 void blitter_0x2c01002c(void)
7792 {
7793         while (outer_loop--)
7794         {
7795                 inner_loop=n_pixels;
7796                 while (inner_loop--)
7797                 {
7798                         uint32 srcdata   = 0;
7799                         uint32 srczdata  = 0;
7800                         uint32 dstdata   = 0;
7801                         uint32 dstzdata  = 0;
7802                         uint32 writedata = 0;
7803                         uint32 inhibit   = 0;
7804                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
7805                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
7806                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
7807                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
7808                         if (!inhibit)
7809                         {
7810                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
7811                         } else { srczdata=dstzdata; writedata=dstdata; }
7812                         if (!inhibit)
7813                         {
7814                                 WRITE_PIXEL_16(a1, writedata);
7815                         }
7816                         a1_x += a1_xadd;
7817                         a1_y += a1_yadd;
7818                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7819                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7820                 }
7821                 a1_x+=a1_step_x;
7822                 a1_y+=a1_step_y;
7823                 a2_x+=a2_step_x;
7824                 a2_y+=a2_step_y;
7825         }
7826         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7827         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7828         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7829 }
7830 #endif
7831 #ifndef blitter_code_0x30c042e4
7832 #define blitter_code_0x30c042e4
7833 void blitter_0x30c042e4(void)
7834 {
7835         while (outer_loop--)
7836         {
7837                 inner_loop=n_pixels;
7838                 while (inner_loop--)
7839                 {
7840                         uint32 srcdata   = 0;
7841                         uint32 srczdata  = 0;
7842                         uint32 dstdata   = 0;
7843                         uint32 dstzdata  = 0;
7844                         uint32 writedata = 0;
7845                         uint32 inhibit   = 0;
7846                         srcdata = READ_PIXEL_16(a1);
7847                         dstdata = READ_PIXEL_16(a2);
7848                         dstzdata = READ_RDATA_16(DSTZ, a2, a2_phrase_mode);
7849                         if (srcdata == READ_RDATA_16(PATTERNDATA, a1,a1_phrase_mode)) inhibit=1;
7850                         if (!inhibit)
7851                         {
7852                                 writedata |= srcdata  & ~dstdata;
7853                                 writedata |= srcdata  & dstdata;
7854                         } else { srczdata=dstzdata; writedata=dstdata; }
7855                         WRITE_PIXEL_16(a2, writedata);
7856                         a1_x += a1_xadd;
7857                         a1_y += a1_yadd;
7858                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7859                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7860                 }
7861                 a1_x+=a1_step_x;
7862                 a1_y+=a1_step_y;
7863                 a2_x+=a2_step_x;
7864                 a2_y+=a2_step_y;
7865         }
7866         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7867         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7868         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7869 }
7870 #endif
7871 #ifndef blitter_code_0x3c01002c
7872 #define blitter_code_0x3c01002c
7873 void blitter_0x3c01002c(void)
7874 {
7875         while (outer_loop--)
7876         {
7877                 inner_loop=n_pixels;
7878                 while (inner_loop--)
7879                 {
7880                         uint32 srcdata   = 0;
7881                         uint32 srczdata  = 0;
7882                         uint32 dstdata   = 0;
7883                         uint32 dstzdata  = 0;
7884                         uint32 writedata = 0;
7885                         uint32 inhibit   = 0;
7886                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
7887                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
7888                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
7889                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
7890                         if (!inhibit)
7891                         {
7892                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
7893                         } else { srczdata=dstzdata; writedata=dstdata; }
7894                         WRITE_PIXEL_16(a1, writedata);
7895                         a1_x += a1_xadd;
7896                         a1_y += a1_yadd;
7897                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7898                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7899                 }
7900                 a1_x+=a1_step_x;
7901                 a1_y+=a1_step_y;
7902                 a2_x+=a2_step_x;
7903                 a2_y+=a2_step_y;
7904         }
7905         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7906         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7907         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7908 }
7909 #endif
7910 #ifndef blitter_code_0x0cc10212
7911 #define blitter_code_0x0cc10212
7912 void blitter_0x0cc10212(void)
7913 {
7914         while (outer_loop--)
7915         {
7916                 inner_loop=n_pixels;
7917                 while (inner_loop--)
7918                 {
7919                         uint32 srcdata   = 0;
7920                         uint32 srczdata  = 0;
7921                         uint32 dstdata   = 0;
7922                         uint32 dstzdata  = 0;
7923                         uint32 writedata = 0;
7924                         uint32 inhibit   = 0;
7925                         srcdata = READ_RDATA_4(SRCDATA, a2, a2_phrase_mode);
7926                         srczdata = READ_RDATA_4(SRCZINT, a2, a2_phrase_mode);
7927                         dstdata = READ_PIXEL_4(a1);
7928                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
7929                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
7930                         if (!inhibit)
7931                         {
7932                                 writedata= READ_RDATA_4(PATTERNDATA, a1, a1_phrase_mode);
7933                         } else { srczdata=dstzdata; writedata=dstdata; }
7934                         if (!inhibit)
7935                         {
7936                                 WRITE_PIXEL_4(a1, writedata);
7937                         }
7938                         a1_x += a1_xadd;
7939                         a1_y += a1_yadd;
7940                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7941                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7942                 }
7943                 a1_x+=a1_step_x;
7944                 a1_y+=a1_step_y;
7945                 a2_x+=a2_step_x;
7946                 a2_y+=a2_step_y;
7947         }
7948         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7949         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7950         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7951 }
7952 #endif
7953 #ifndef blitter_code_0x38000301
7954 #define blitter_code_0x38000301
7955 void blitter_0x38000301(void)
7956 {
7957         while (outer_loop--)
7958         {
7959                 inner_loop=n_pixels;
7960                 while (inner_loop--)
7961                 {
7962                         uint32 srcdata   = 0;
7963                         uint32 srczdata  = 0;
7964                         uint32 dstdata   = 0;
7965                         uint32 dstzdata  = 0;
7966                         uint32 writedata = 0;
7967                         uint32 inhibit   = 0;
7968                         srcdata = READ_RDATA_2(SRCDATA, a2, a2_phrase_mode);
7969                         dstdata = READ_PIXEL_2(a1);
7970                         dstzdata = READ_RDATA_2(DSTZ, a1, a1_phrase_mode);
7971                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
7972                         if (!inhibit)
7973                         {
7974                         } else { srczdata=dstzdata; writedata=dstdata; }
7975                         WRITE_PIXEL_2(a1, writedata);
7976                         a1_x += a1_xadd;
7977                         a1_y += a1_yadd;
7978                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
7979                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
7980                 }
7981                 a1_x+=a1_step_x;
7982                 a1_y+=a1_step_y;
7983                 a2_x+=a2_step_x;
7984                 a2_y+=a2_step_y;
7985         }
7986         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
7987         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
7988         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
7989 }
7990 #endif
7991 #ifndef blitter_code_0x2401002b
7992 #define blitter_code_0x2401002b
7993 void blitter_0x2401002b(void)
7994 {
7995         while (outer_loop--)
7996         {
7997                 inner_loop=n_pixels;
7998                 while (inner_loop--)
7999                 {
8000                         uint32 srcdata   = 0;
8001                         uint32 srczdata  = 0;
8002                         uint32 dstdata   = 0;
8003                         uint32 dstzdata  = 0;
8004                         uint32 writedata = 0;
8005                         uint32 inhibit   = 0;
8006                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
8007                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
8008                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
8009                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
8010                                 WRITE_PIXEL_8(a1, writedata);
8011                         a1_x += a1_xadd;
8012                         a1_y += a1_yadd;
8013                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8014                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8015                 }
8016                 a1_x+=a1_step_x;
8017                 a1_y+=a1_step_y;
8018                 a2_x+=a2_step_x;
8019                 a2_y+=a2_step_y;
8020         }
8021         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8022         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8023         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8024 }
8025 #endif
8026 #ifndef blitter_code_0x30c004ad
8027 #define blitter_code_0x30c004ad
8028 void blitter_0x30c004ad(void)
8029 {
8030         while (outer_loop--)
8031         {
8032                 inner_loop=n_pixels;
8033                 while (inner_loop--)
8034                 {
8035                         uint32 srcdata   = 0;
8036                         uint32 srczdata  = 0;
8037                         uint32 dstdata   = 0;
8038                         uint32 dstzdata  = 0;
8039                         uint32 writedata = 0;
8040                         uint32 inhibit   = 0;
8041                         srcdata = READ_PIXEL_32(a2);
8042                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
8043                         dstzdata = READ_RDATA_32(DSTZ, a1, a1_phrase_mode);
8044                                 writedata |= srcdata  & ~dstdata;
8045                                 writedata |= srcdata  & dstdata;
8046                         WRITE_PIXEL_32(a1, writedata);
8047                         a1_x += a1_xadd;
8048                         a1_y += a1_yadd;
8049                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8050                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8051                 }
8052                 a1_x+=a1_step_x;
8053                 a1_y+=a1_step_y;
8054                 a2_x+=a2_step_x;
8055                 a2_y+=a2_step_y;
8056         }
8057         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8058         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8059         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8060 }
8061 #endif
8062 #ifndef blitter_code_0x04012000
8063 #define blitter_code_0x04012000
8064 void blitter_0x04012000(void)
8065 {
8066         while (outer_loop--)
8067         {
8068                 inner_loop=n_pixels;
8069                 while (inner_loop--)
8070                 {
8071                         uint32 srcdata   = 0;
8072                         uint32 srczdata  = 0;
8073                         uint32 dstdata   = 0;
8074                         uint32 dstzdata  = 0;
8075                         uint32 writedata = 0;
8076                         uint32 inhibit   = 0;
8077                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
8078                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
8079                         dstdata = READ_RDATA_1(DSTDATA, a1, a1_phrase_mode);
8080                         srczdata=z_i[colour_index]>>16;
8081                         if (srczdata >  dstzdata)       inhibit = 1;
8082                         if (!inhibit)
8083                         {
8084                                 writedata= READ_RDATA_1(PATTERNDATA, a1, a1_phrase_mode);
8085                         } else { srczdata=dstzdata; writedata=dstdata; }
8086                         if (!inhibit)
8087                         {
8088                                 WRITE_PIXEL_1(a1, writedata);
8089                         }
8090                         a1_x += a1_xadd;
8091                         a1_y += a1_yadd;
8092                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8093                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8094                         z_i[colour_index]+=zadd;
8095                 }
8096                 a1_x+=a1_step_x;
8097                 a1_y+=a1_step_y;
8098                 a2_x+=a2_step_x;
8099                 a2_y+=a2_step_y;
8100         }
8101         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8102         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8103         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8104 }
8105 #endif
8106 #ifndef blitter_code_0x34012000
8107 #define blitter_code_0x34012000
8108 void blitter_0x34012000(void)
8109 {
8110         while (outer_loop--)
8111         {
8112                 inner_loop=n_pixels;
8113                 while (inner_loop--)
8114                 {
8115                         uint32 srcdata   = 0;
8116                         uint32 srczdata  = 0;
8117                         uint32 dstdata   = 0;
8118                         uint32 dstzdata  = 0;
8119                         uint32 writedata = 0;
8120                         uint32 inhibit   = 0;
8121                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
8122                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
8123                         dstdata = READ_RDATA_1(DSTDATA, a1, a1_phrase_mode);
8124                         srczdata=z_i[colour_index]>>16;
8125                         if (srczdata >  dstzdata)       inhibit = 1;
8126                         if (!inhibit)
8127                         {
8128                                 writedata= READ_RDATA_1(PATTERNDATA, a1, a1_phrase_mode);
8129                         } else { srczdata=dstzdata; writedata=dstdata; }
8130                         WRITE_PIXEL_1(a1, writedata);
8131                         a1_x += a1_xadd;
8132                         a1_y += a1_yadd;
8133                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8134                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8135                         z_i[colour_index]+=zadd;
8136                          colour_index=(colour_index+1)&0x3;
8137                 }
8138                 a1_x+=a1_step_x;
8139                 a1_y+=a1_step_y;
8140                 a2_x+=a2_step_x;
8141                 a2_y+=a2_step_y;
8142         }
8143         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8144         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8145         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8146 }
8147 #endif
8148 #ifndef blitter_code_0x30c004ad
8149 #define blitter_code_0x30c004ad
8150 void blitter_0x30c004ad(void)
8151 {
8152         while (outer_loop--)
8153         {
8154                 inner_loop=n_pixels;
8155                 while (inner_loop--)
8156                 {
8157                         uint32 srcdata   = 0;
8158                         uint32 srczdata  = 0;
8159                         uint32 dstdata   = 0;
8160                         uint32 dstzdata  = 0;
8161                         uint32 writedata = 0;
8162                         uint32 inhibit   = 0;
8163                         srcdata = READ_PIXEL_32(a2);
8164                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
8165                         dstzdata = READ_RDATA_32(DSTZ, a1, a1_phrase_mode);
8166                                 writedata |= srcdata  & ~dstdata;
8167                                 writedata |= srcdata  & dstdata;
8168                         WRITE_PIXEL_32(a1, writedata);
8169                         a1_x += a1_xadd;
8170                         a1_y += a1_yadd;
8171                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8172                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8173                 }
8174                 a1_x+=a1_step_x;
8175                 a1_y+=a1_step_y;
8176                 a2_x+=a2_step_x;
8177                 a2_y+=a2_step_y;
8178         }
8179         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8180         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8181         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8182 }
8183 #endif
8184 #ifndef blitter_code_0x04012000
8185 #define blitter_code_0x04012000
8186 void blitter_0x04012000(void)
8187 {
8188         while (outer_loop--)
8189         {
8190                 inner_loop=n_pixels;
8191                 while (inner_loop--)
8192                 {
8193                         uint32 srcdata   = 0;
8194                         uint32 srczdata  = 0;
8195                         uint32 dstdata   = 0;
8196                         uint32 dstzdata  = 0;
8197                         uint32 writedata = 0;
8198                         uint32 inhibit   = 0;
8199                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
8200                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
8201                         dstdata = READ_RDATA_1(DSTDATA, a1, a1_phrase_mode);
8202                         srczdata=z_i[colour_index]>>16;
8203                         if (srczdata >  dstzdata)       inhibit = 1;
8204                         if (!inhibit)
8205                         {
8206                                 writedata= READ_RDATA_1(PATTERNDATA, a1, a1_phrase_mode);
8207                         } else { srczdata=dstzdata; writedata=dstdata; }
8208                         if (!inhibit)
8209                         {
8210                                 WRITE_PIXEL_1(a1, writedata);
8211                         }
8212                         a1_x += a1_xadd;
8213                         a1_y += a1_yadd;
8214                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8215                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8216                         z_i[colour_index]+=zadd;
8217                 }
8218                 a1_x+=a1_step_x;
8219                 a1_y+=a1_step_y;
8220                 a2_x+=a2_step_x;
8221                 a2_y+=a2_step_y;
8222         }
8223         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8224         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8225         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8226 }
8227 #endif
8228 #ifndef blitter_code_0x34012000
8229 #define blitter_code_0x34012000
8230 void blitter_0x34012000(void)
8231 {
8232         while (outer_loop--)
8233         {
8234                 inner_loop=n_pixels;
8235                 while (inner_loop--)
8236                 {
8237                         uint32 srcdata   = 0;
8238                         uint32 srczdata  = 0;
8239                         uint32 dstdata   = 0;
8240                         uint32 dstzdata  = 0;
8241                         uint32 writedata = 0;
8242                         uint32 inhibit   = 0;
8243                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
8244                         srczdata = READ_RDATA_1(SRCZINT, a2, a2_phrase_mode);
8245                         dstdata = READ_RDATA_1(DSTDATA, a1, a1_phrase_mode);
8246                         srczdata=z_i[colour_index]>>16;
8247                         if (srczdata >  dstzdata)       inhibit = 1;
8248                         if (!inhibit)
8249                         {
8250                                 writedata= READ_RDATA_1(PATTERNDATA, a1, a1_phrase_mode);
8251                         } else { srczdata=dstzdata; writedata=dstdata; }
8252                         WRITE_PIXEL_1(a1, writedata);
8253                         a1_x += a1_xadd;
8254                         a1_y += a1_yadd;
8255                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8256                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8257                         z_i[colour_index]+=zadd;
8258                          colour_index=(colour_index+1)&0x3;
8259                 }
8260                 a1_x+=a1_step_x;
8261                 a1_y+=a1_step_y;
8262                 a2_x+=a2_step_x;
8263                 a2_y+=a2_step_y;
8264         }
8265         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8266         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8267         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8268 }
8269 #endif
8270 #ifndef blitter_code_0x30808c92
8271 #define blitter_code_0x30808c92
8272 void blitter_0x30808c92(void)
8273 {
8274         while (outer_loop--)
8275         {
8276                 inner_loop=n_pixels;
8277                 while (inner_loop--)
8278                 {
8279                         uint32 srcdata   = 0;
8280                         uint32 srczdata  = 0;
8281                         uint32 dstdata   = 0;
8282                         uint32 dstzdata  = 0;
8283                         uint32 writedata = 0;
8284                         uint32 inhibit   = 0;
8285                         srcdata = READ_PIXEL_4(a2);
8286                         dstdata = READ_RDATA_4(DSTDATA, a1, a1_phrase_mode);
8287                         dstzdata = READ_RDATA_4(DSTZ, a1, a1_phrase_mode);
8288                         if (srczdata <  dstzdata)       inhibit = 1;
8289                         if (!inhibit)
8290                         {
8291                                 writedata |= srcdata  & dstdata;
8292                         } else { srczdata=dstzdata; writedata=dstdata; }
8293                         WRITE_PIXEL_4(a1, writedata);
8294                         a1_x += a1_xadd;
8295                         a1_y += a1_yadd;
8296                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8297                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8298                 }
8299                 a1_x+=a1_step_x;
8300                 a1_y+=a1_step_y;
8301                 a2_x+=a2_step_x;
8302                 a2_y+=a2_step_y;
8303         }
8304         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8305         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8306         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8307 }
8308 #endif
8309 #ifndef blitter_code_0x0040409b
8310 #define blitter_code_0x0040409b
8311 void blitter_0x0040409b(void)
8312 {
8313         while (outer_loop--)
8314         {
8315                 inner_loop=n_pixels;
8316                 while (inner_loop--)
8317                 {
8318                         uint32 srcdata   = 0;
8319                         uint32 srczdata  = 0;
8320                         uint32 dstdata   = 0;
8321                         uint32 dstzdata  = 0;
8322                         uint32 writedata = 0;
8323                         uint32 inhibit   = 0;
8324                         srcdata = READ_PIXEL_8(a2);
8325                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
8326                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
8327                         if (!inhibit)
8328                         {
8329                                 writedata |= srcdata  & ~dstdata;
8330                         } else { srczdata=dstzdata; writedata=dstdata; }
8331                         if (!inhibit)
8332                         {
8333                                 WRITE_PIXEL_8(a1, writedata);
8334                         }
8335                         a1_x += a1_xadd;
8336                         a1_y += a1_yadd;
8337                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8338                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8339                 }
8340                 a1_x+=a1_step_x;
8341                 a1_y+=a1_step_y;
8342                 a2_x+=a2_step_x;
8343                 a2_y+=a2_step_y;
8344         }
8345         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8346         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8347         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8348 }
8349 #endif
8350 #ifndef blitter_code_0x1000001d
8351 #define blitter_code_0x1000001d
8352 void blitter_0x1000001d(void)
8353 {
8354         while (outer_loop--)
8355         {
8356                 inner_loop=n_pixels;
8357                 while (inner_loop--)
8358                 {
8359                         uint32 srcdata   = 0;
8360                         uint32 srczdata  = 0;
8361                         uint32 dstdata   = 0;
8362                         uint32 dstzdata  = 0;
8363                         uint32 writedata = 0;
8364                         uint32 inhibit   = 0;
8365                         srcdata = READ_RDATA_32(SRCDATA, a2, a2_phrase_mode);
8366                         dstdata = READ_RDATA_32(DSTDATA, a1, a1_phrase_mode);
8367                         if (!inhibit)
8368                         {
8369                         } else { srczdata=dstzdata; writedata=dstdata; }
8370                         WRITE_PIXEL_32(a1, writedata);
8371                         a1_x += a1_xadd;
8372                         a1_y += a1_yadd;
8373                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8374                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8375                 }
8376                 a1_x+=a1_step_x;
8377                 a1_y+=a1_step_y;
8378                 a2_x+=a2_step_x;
8379                 a2_y+=a2_step_y;
8380         }
8381         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8382         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8383         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8384 }
8385 #endif
8386 #ifndef blitter_code_0x0000409b
8387 #define blitter_code_0x0000409b
8388 void blitter_0x0000409b(void)
8389 {
8390         while (outer_loop--)
8391         {
8392                 inner_loop=n_pixels;
8393                 while (inner_loop--)
8394                 {
8395                         uint32 srcdata   = 0;
8396                         uint32 srczdata  = 0;
8397                         uint32 dstdata   = 0;
8398                         uint32 dstzdata  = 0;
8399                         uint32 writedata = 0;
8400                         uint32 inhibit   = 0;
8401                         srcdata = READ_PIXEL_8(a2);
8402                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
8403                         if (srcdata == READ_RDATA_8(PATTERNDATA, a2,a2_phrase_mode)) inhibit=1;
8404                         if (!inhibit)
8405                         {
8406                         } else { srczdata=dstzdata; writedata=dstdata; }
8407                         if (!inhibit)
8408                         {
8409                                 WRITE_PIXEL_8(a1, writedata);
8410                         }
8411                         a1_x += a1_xadd;
8412                         a1_y += a1_yadd;
8413                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8414                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8415                 }
8416                 a1_x+=a1_step_x;
8417                 a1_y+=a1_step_y;
8418                 a2_x+=a2_step_x;
8419                 a2_y+=a2_step_y;
8420         }
8421         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8422         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8423         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8424 }
8425 #endif
8426 #ifndef blitter_code_0x0cc10024
8427 #define blitter_code_0x0cc10024
8428 void blitter_0x0cc10024(void)
8429 {
8430         while (outer_loop--)
8431         {
8432                 inner_loop=n_pixels;
8433                 while (inner_loop--)
8434                 {
8435                         uint32 srcdata   = 0;
8436                         uint32 srczdata  = 0;
8437                         uint32 dstdata   = 0;
8438                         uint32 dstzdata  = 0;
8439                         uint32 writedata = 0;
8440                         uint32 inhibit   = 0;
8441                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
8442                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
8443                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
8444                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
8445                         if (!inhibit)
8446                         {
8447                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
8448                         } else { srczdata=dstzdata; writedata=dstdata; }
8449                         if (!inhibit)
8450                         {
8451                                 WRITE_PIXEL_16(a1, writedata);
8452                         }
8453                         a1_x += a1_xadd;
8454                         a1_y += a1_yadd;
8455                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8456                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8457                 }
8458                 a1_x+=a1_step_x;
8459                 a1_y+=a1_step_y;
8460                 a2_x+=a2_step_x;
8461                 a2_y+=a2_step_y;
8462         }
8463         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8464         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8465         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8466 }
8467 #endif
8468 #ifndef blitter_code_0x2401001b
8469 #define blitter_code_0x2401001b
8470 void blitter_0x2401001b(void)
8471 {
8472         while (outer_loop--)
8473         {
8474                 inner_loop=n_pixels;
8475                 while (inner_loop--)
8476                 {
8477                         uint32 srcdata   = 0;
8478                         uint32 srczdata  = 0;
8479                         uint32 dstdata   = 0;
8480                         uint32 dstzdata  = 0;
8481                         uint32 writedata = 0;
8482                         uint32 inhibit   = 0;
8483                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
8484                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
8485                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
8486                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
8487                                 WRITE_PIXEL_8(a1, writedata);
8488                         a1_x += a1_xadd;
8489                         a1_y += a1_yadd;
8490                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8491                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8492                 }
8493                 a1_x+=a1_step_x;
8494                 a1_y+=a1_step_y;
8495                 a2_x+=a2_step_x;
8496                 a2_y+=a2_step_y;
8497         }
8498         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8499         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8500         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8501 }
8502 #endif
8503 #ifndef blitter_code_0x01c042db
8504 #define blitter_code_0x01c042db
8505 void blitter_0x01c042db(void)
8506 {
8507         while (outer_loop--)
8508         {
8509                 inner_loop=n_pixels;
8510                 while (inner_loop--)
8511                 {
8512                         uint32 srcdata   = 0;
8513                         uint32 srczdata  = 0;
8514                         uint32 dstdata   = 0;
8515                         uint32 dstzdata  = 0;
8516                         uint32 writedata = 0;
8517                         uint32 inhibit   = 0;
8518                         srcdata = READ_PIXEL_8(a1);
8519                         dstdata = READ_PIXEL_8(a2);
8520                         dstzdata = READ_RDATA_8(DSTZ, a2, a2_phrase_mode);
8521                         if (srcdata == READ_RDATA_8(PATTERNDATA, a1,a1_phrase_mode)) inhibit=1;
8522                         if (!inhibit)
8523                         {
8524                                 writedata |= srcdata  & ~dstdata;
8525                                 writedata |= srcdata  & dstdata;
8526                         } else { srczdata=dstzdata; writedata=dstdata; }
8527                         WRITE_PIXEL_8(a2, writedata);
8528                         a1_x += a1_xadd;
8529                         a1_y += a1_yadd;
8530                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8531                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8532                 }
8533                 a1_x+=a1_step_x;
8534                 a1_y+=a1_step_y;
8535                 a2_x+=a2_step_x;
8536                 a2_y+=a2_step_y;
8537         }
8538         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8539         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8540         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8541 }
8542 #endif
8543 #ifndef blitter_code_0x34010224
8544 #define blitter_code_0x34010224
8545 void blitter_0x34010224(void)
8546 {
8547         while (outer_loop--)
8548         {
8549                 inner_loop=n_pixels;
8550                 while (inner_loop--)
8551                 {
8552                         uint32 srcdata   = 0;
8553                         uint32 srczdata  = 0;
8554                         uint32 dstdata   = 0;
8555                         uint32 dstzdata  = 0;
8556                         uint32 writedata = 0;
8557                         uint32 inhibit   = 0;
8558                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
8559                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
8560                         dstdata = READ_PIXEL_16(a1);
8561                         dstzdata = READ_RDATA_16(DSTZ, a1, a1_phrase_mode);
8562                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
8563                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
8564                         WRITE_PIXEL_16(a1, writedata);
8565                         a1_x += a1_xadd;
8566                         a1_y += a1_yadd;
8567                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8568                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8569                         gd_i[colour_index] += gd_ia;
8570                         gd_c[colour_index] += gd_ca;
8571                          colour_index=(colour_index+1)&0x3;
8572                 }
8573                 a1_x+=a1_step_x;
8574                 a1_y+=a1_step_y;
8575                 a2_x+=a2_step_x;
8576                 a2_y+=a2_step_y;
8577         }
8578         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8579         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8580         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8581 }
8582 #endif
8583 #ifndef blitter_code_0x30808800
8584 #define blitter_code_0x30808800
8585 void blitter_0x30808800(void)
8586 {
8587         while (outer_loop--)
8588         {
8589                 inner_loop=n_pixels;
8590                 while (inner_loop--)
8591                 {
8592                         uint32 srcdata   = 0;
8593                         uint32 srczdata  = 0;
8594                         uint32 dstdata   = 0;
8595                         uint32 dstzdata  = 0;
8596                         uint32 writedata = 0;
8597                         uint32 inhibit   = 0;
8598                         srcdata = READ_RDATA_1(SRCDATA, a2, a2_phrase_mode);
8599                         dstdata = READ_RDATA_1(DSTDATA, a1, a1_phrase_mode);
8600                         if (srczdata <  dstzdata)       inhibit = 1;
8601                         if (!inhibit)
8602                         {
8603                                 writedata |= srcdata  & dstdata;
8604                         } else { srczdata=dstzdata; writedata=dstdata; }
8605                         WRITE_PIXEL_1(a1, writedata);
8606                         a1_x += a1_xadd;
8607                         a1_y += a1_yadd;
8608                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8609                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8610                 }
8611                 a1_x+=a1_step_x;
8612                 a1_y+=a1_step_y;
8613                 a2_x+=a2_step_x;
8614                 a2_y+=a2_step_y;
8615         }
8616         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8617         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8618         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8619 }
8620 #endif
8621 #ifndef blitter_code_0x06c026e4
8622 #define blitter_code_0x06c026e4
8623 void blitter_0x06c026e4(void)
8624 {
8625         while (outer_loop--)
8626         {
8627                 inner_loop=n_pixels;
8628                 while (inner_loop--)
8629                 {
8630                         uint32 srcdata   = 0;
8631                         uint32 srczdata  = 0;
8632                         uint32 dstdata   = 0;
8633                         uint32 dstzdata  = 0;
8634                         uint32 writedata = 0;
8635                         uint32 inhibit   = 0;
8636                         srcdata = READ_PIXEL_16(a1);
8637                         srczdata = READ_RDATA_16(SRCZINT, a1, a1_phrase_mode);
8638                         dstdata = READ_PIXEL_16(a2);
8639                         dstzdata = READ_ZDATA_16(a2);
8640                         srczdata=z_i[colour_index]>>16;
8641                         if (srczdata >  dstzdata)       inhibit = 1;
8642                         if (!inhibit)
8643                         {
8644                                 writedata |= srcdata  & ~dstdata;
8645                                 writedata |= srcdata  & dstdata;
8646                         } else { srczdata=dstzdata; writedata=dstdata; }
8647                         if (!inhibit)
8648                         {
8649                                 WRITE_PIXEL_16(a2, writedata);
8650                                 WRITE_ZDATA_16(a2, srczdata);
8651                         }
8652                         a1_x += a1_xadd;
8653                         a1_y += a1_yadd;
8654                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8655                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8656                         z_i[colour_index]+=zadd;
8657                 }
8658                 a1_x+=a1_step_x;
8659                 a1_y+=a1_step_y;
8660                 a2_x+=a2_step_x;
8661                 a2_y+=a2_step_y;
8662         }
8663         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8664         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8665         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8666 }
8667 #endif
8668 #ifndef blitter_code_0x06012624
8669 #define blitter_code_0x06012624
8670 void blitter_0x06012624(void)
8671 {
8672         while (outer_loop--)
8673         {
8674                 inner_loop=n_pixels;
8675                 while (inner_loop--)
8676                 {
8677                         uint32 srcdata   = 0;
8678                         uint32 srczdata  = 0;
8679                         uint32 dstdata   = 0;
8680                         uint32 dstzdata  = 0;
8681                         uint32 writedata = 0;
8682                         uint32 inhibit   = 0;
8683                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
8684                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
8685                         dstdata = READ_PIXEL_16(a1);
8686                         dstzdata = READ_ZDATA_16(a1);
8687                         srczdata=z_i[colour_index]>>16;
8688                         if (srczdata >  dstzdata)       inhibit = 1;
8689                         if (!inhibit)
8690                         {
8691                                 writedata= READ_RDATA_16(PATTERNDATA, a1, a1_phrase_mode);
8692                                 writedata = ((gd_c[colour_index])<<8)|(gd_i[colour_index]>>16);
8693                         } else { srczdata=dstzdata; writedata=dstdata; }
8694                         if (!inhibit)
8695                         {
8696                                 WRITE_PIXEL_16(a1, writedata);
8697                                 WRITE_ZDATA_16(a1, srczdata);
8698                         }
8699                         a1_x += a1_xadd;
8700                         a1_y += a1_yadd;
8701                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8702                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8703                         z_i[colour_index]+=zadd;
8704                         gd_i[colour_index] += gd_ia;
8705                         gd_c[colour_index] += gd_ca;
8706                 }
8707                 a1_x+=a1_step_x;
8708                 a1_y+=a1_step_y;
8709                 a2_x+=a2_step_x;
8710                 a2_y+=a2_step_y;
8711         }
8712         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8713         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8714         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8715 }
8716 #endif
8717 #ifndef blitter_code_0x000200e4
8718 #define blitter_code_0x000200e4
8719 void blitter_0x000200e4(void)
8720 {
8721         while (outer_loop--)
8722         {
8723                 inner_loop=n_pixels;
8724                 while (inner_loop--)
8725                 {
8726                         uint32 srcdata   = 0;
8727                         uint32 srczdata  = 0;
8728                         uint32 dstdata   = 0;
8729                         uint32 dstzdata  = 0;
8730                         uint32 writedata = 0;
8731                         uint32 inhibit   = 0;
8732                         srcdata = READ_PIXEL_16(a1);
8733                         dstdata = READ_RDATA_16(DSTDATA, a2, a2_phrase_mode);
8734                         if (!inhibit)
8735                         {
8736                                 writedata = (srcdata & 0xff) + (dstdata & 0xff);
8737                                 if (writedata > 0xff) writedata = 0xff;
8738                                 writedata |= (srcdata & 0xf00) + (dstdata & 0xf00);
8739                                 if (writedata > 0xfff) writedata = 0xfff;
8740                                 writedata |= (srcdata & 0xf000) + (dstdata & 0xf000);
8741                         } else { srczdata=dstzdata; writedata=dstdata; }
8742                         if (!inhibit)
8743                         {
8744                                 WRITE_PIXEL_16(a2, writedata);
8745                         }
8746                         a1_x += a1_xadd;
8747                         a1_y += a1_yadd;
8748                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8749                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8750                 }
8751                 a1_x+=a1_step_x;
8752                 a1_y+=a1_step_y;
8753                 a2_x+=a2_step_x;
8754                 a2_y+=a2_step_y;
8755         }
8756         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8757         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8758         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8759 }
8760 #endif
8761 #ifndef blitter_code_0x37c026a4
8762 #define blitter_code_0x37c026a4
8763 void blitter_0x37c026a4(void)
8764 {
8765         while (outer_loop--)
8766         {
8767                 inner_loop=n_pixels;
8768                 while (inner_loop--)
8769                 {
8770                         uint32 srcdata   = 0;
8771                         uint32 srczdata  = 0;
8772                         uint32 dstdata   = 0;
8773                         uint32 dstzdata  = 0;
8774                         uint32 writedata = 0;
8775                         uint32 inhibit   = 0;
8776                         srcdata = READ_PIXEL_16(a2);
8777                         srczdata = READ_RDATA_16(SRCZINT, a2, a2_phrase_mode);
8778                         dstdata = READ_PIXEL_16(a1);
8779                         dstzdata = READ_ZDATA_16(a1);
8780                         srczdata=z_i[colour_index]>>16;
8781                         if (srczdata >  dstzdata)       inhibit = 1;
8782                         if (!inhibit)
8783                         {
8784                                 writedata |= srcdata  & ~dstdata;
8785                                 writedata |= srcdata  & dstdata;
8786                         } else { srczdata=dstzdata; writedata=dstdata; }
8787                         WRITE_PIXEL_16(a1, writedata);
8788                         WRITE_ZDATA_16(a1, srczdata);
8789                         a1_x += a1_xadd;
8790                         a1_y += a1_yadd;
8791                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8792                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8793                         z_i[colour_index]+=zadd;
8794                          colour_index=(colour_index+1)&0x3;
8795                 }
8796                 a1_x+=a1_step_x;
8797                 a1_y+=a1_step_y;
8798                 a2_x+=a2_step_x;
8799                 a2_y+=a2_step_y;
8800         }
8801         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8802         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8803         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8804 }
8805 #endif
8806 #ifndef blitter_code_0x3c01001b
8807 #define blitter_code_0x3c01001b
8808 void blitter_0x3c01001b(void)
8809 {
8810         while (outer_loop--)
8811         {
8812                 inner_loop=n_pixels;
8813                 while (inner_loop--)
8814                 {
8815                         uint32 srcdata   = 0;
8816                         uint32 srczdata  = 0;
8817                         uint32 dstdata   = 0;
8818                         uint32 dstzdata  = 0;
8819                         uint32 writedata = 0;
8820                         uint32 inhibit   = 0;
8821                         srcdata = READ_RDATA_8(SRCDATA, a2, a2_phrase_mode);
8822                         srczdata = READ_RDATA_8(SRCZINT, a2, a2_phrase_mode);
8823                         dstdata = READ_RDATA_8(DSTDATA, a1, a1_phrase_mode);
8824                         if (a1_x < 0 || a1_y < 0 || (a1_x >> 16) >= (REG(A1_CLIP) & 0x7fff) || (a1_y >> 16) >= ((REG(A1_CLIP) >> 16) & 0x7fff)) inhibit = 1;
8825                         if (!inhibit)
8826                         {
8827                                 writedata= READ_RDATA_8(PATTERNDATA, a1, a1_phrase_mode);
8828                         } else { srczdata=dstzdata; writedata=dstdata; }
8829                         WRITE_PIXEL_8(a1, writedata);
8830                         a1_x += a1_xadd;
8831                         a1_y += a1_yadd;
8832                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8833                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8834                 }
8835                 a1_x+=a1_step_x;
8836                 a1_y+=a1_step_y;
8837                 a2_x+=a2_step_x;
8838                 a2_y+=a2_step_y;
8839         }
8840         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8841         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8842         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8843 }
8844 #endif
8845 #ifndef blitter_code_0x2401006b
8846 #define blitter_code_0x2401006b
8847 void blitter_0x2401006b(void)
8848 {
8849         while (outer_loop--)
8850         {
8851                 inner_loop=n_pixels;
8852                 while (inner_loop--)
8853                 {
8854                         uint32 srcdata   = 0;
8855                         uint32 srczdata  = 0;
8856                         uint32 dstdata   = 0;
8857                         uint32 dstzdata  = 0;
8858                         uint32 writedata = 0;
8859                         uint32 inhibit   = 0;
8860                         srcdata = READ_RDATA_32(SRCDATA, a1, a1_phrase_mode);
8861                         srczdata = READ_RDATA_32(SRCZINT, a1, a1_phrase_mode);
8862                         dstdata = READ_RDATA_32(DSTDATA, a2, a2_phrase_mode);
8863                         if (!inhibit)
8864                         {
8865                                 writedata= READ_RDATA_32(PATTERNDATA, a2, a2_phrase_mode);
8866                         } else { srczdata=dstzdata; writedata=dstdata; }
8867                         WRITE_PIXEL_32(a2, writedata);
8868                         a1_x += a1_xadd;
8869                         a1_y += a1_yadd;
8870                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8871                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8872                 }
8873                 a1_x+=a1_step_x;
8874                 a1_y+=a1_step_y;
8875                 a2_x+=a2_step_x;
8876                 a2_y+=a2_step_y;
8877         }
8878         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8879         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8880         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8881 }
8882 #endif
8883 #ifndef blitter_code_0x30000024
8884 #define blitter_code_0x30000024
8885 void blitter_0x30000024(void)
8886 {
8887         while (outer_loop--)
8888         {
8889                 inner_loop=n_pixels;
8890                 while (inner_loop--)
8891                 {
8892                         uint32 srcdata   = 0;
8893                         uint32 srczdata  = 0;
8894                         uint32 dstdata   = 0;
8895                         uint32 dstzdata  = 0;
8896                         uint32 writedata = 0;
8897                         uint32 inhibit   = 0;
8898                         srcdata = READ_RDATA_16(SRCDATA, a2, a2_phrase_mode);
8899                         dstdata = READ_RDATA_16(DSTDATA, a1, a1_phrase_mode);
8900                         WRITE_PIXEL_16(a1, writedata);
8901                         a1_x += a1_xadd;
8902                         a1_y += a1_yadd;
8903                         a2_x = (a2_x + a2_xadd) & a2_mask_x;
8904                         a2_y = (a2_y + a2_yadd) & a2_mask_y;
8905                 }
8906                 a1_x+=a1_step_x;
8907                 a1_y+=a1_step_y;
8908                 a2_x+=a2_step_x;
8909                 a2_y+=a2_step_y;
8910         }
8911         WREG(A1_PIXEL,  (a1_y & 0xffff0000) | ((a1_x >> 16) & 0xffff));
8912         WREG(A1_FPIXEL, (a1_y << 16) | (a1_x & 0xffff));
8913         WREG(A2_PIXEL,  (a2_y & 0xffff0000) | ((a2_x >> 16) & 0xffff));
8914 }
8915 #endif