PS3 PlayStation 3: Информация, cлухи, домыслы

Тема в разделе "PlayStation 5", создана пользователем Steve, 23 дек 2005.

Статус темы:
Закрыта.
  1. romka

    romka Очень главный

    Сообщения:
    4.450
    Симпатии:
    184
    Баллы:
    203
    Устаревшие сведения. Ещё летом было объявлено, что Ethernet-порт в PS3 будет только один.
     
  2. VaaN

    VaaN Stella Maris

    Сообщения:
    20.807
    Симпатии:
    2.230
    Баллы:
    623
    Ну у меня других пока нет :)
     
  3. ReD Warrior

    ReD Warrior Well-Known Member

    Сообщения:
    12
    Симпатии:
    0
    Баллы:
    58
    Гмм, незнаю но лично мне blu-ray кажется перспективным, если его взломают то можно будет увидеть сборники 20-30 игр PS2 на одном диске, как прям в дендевские времена=)
     
  4. VaaN

    VaaN Stella Maris

    Сообщения:
    20.807
    Симпатии:
    2.230
    Баллы:
    623
    А если взять двухслойный, двухсторонний диск, вообще неограниченные возможности будут. Например сборник - все игры для PS2 на 10 дисках :)
     
  5. Snake

    Snake фотограф-игрун

    Сообщения:
    1.791
    Симпатии:
    348
    Баллы:
    163
    Почему-то сборников хотя бы "5 в 1" игр от PSOne на DVDм ы не видим до сих пор...
     
  6. romka

    romka Очень главный

    Сообщения:
    4.450
    Симпатии:
    184
    Баллы:
    203
    И в будущем таких сборников для PS2 (если не считать торговцев исошками) не будет, могу сказать это с 99% уверенностью. Для PS3 конечно же что-то подобное может и появится, если там действительно будет программная эмуляция предыдущих консолей, а не аппаратная.
     
  7. Patrul

    Patrul New Member

    Сообщения:
    3.624
    Симпатии:
    157
    Баллы:
    0
    За более чем полгода понял: чем больше информации о грядущей "игровой системе" от SONY поступает в мой взрывоопасный головной мозг, тем меньше я жду эту "мегахлебницу". Но купить, наверно, придется - из-за игр, конечно же.
     
  8. Alex Z

    Alex Z Well-Known Member

    Сообщения:
    138
    Симпатии:
    1
    Баллы:
    61
    Вот что мне не нравится в PS3 – это Cell (только не бейте ногами :) ).
    Нет, процессор достаточно мощный (быстрая обработка многопоточных данных, встроенный компилятор, мультизадачность и т.д.), только вот программить под него – это уровень nightmare. Т.е. простыми словами, Cell для программистов – это ад. ;)

    VaaN
    System Floating Point Performance
    Вот это не правда. На самом деле fpp составляет ~ 25 Gflops, если не ошибаюсь. Об этом написано на сайте IBM’а в недавно опубликованной статье про подробный анализ архитектуры Cell. :)
     
  9. VaaN

    VaaN Stella Maris

    Сообщения:
    20.807
    Симпатии:
    2.230
    Баллы:
    623
    Z'Alex
    Ну я же это не сам придумывал ;)
     
  10. Лекс

    Лекс РАЖДЁН, ШТОБ ЖРАТЬ

    Сообщения:
    16.815
    Симпатии:
    550
    Баллы:
    523
    Ты программист? Сам пишешь программы, оптимизируя их на уровне команд для процессора? Если да - расскажи пожалуйста подробнее, если нет - наверное не стоит судить о том, в чём не разбираешься. Не исключено, что это как рах довольно удобное решение, позволяющее решать массу полезных задач довольно простыми способами. Я читал мнения проффесиональных программистов и спор у них был довольно жаркий, кто-то за, кто-то против. Не так всё просто, как может показаться на первый взгляд.
     
  11. VaaN

    VaaN Stella Maris

    Сообщения:
    20.807
    Симпатии:
    2.230
    Баллы:
    623
    А я всегда говорил, чем сложнее тем лучше. Со временем графика будет только улучшаться, или вы хотите на старте получить лучшую графику, а потом все 5 лет смотреть на одно и то же?

    PS До CES осталось 2 дня.
     
  12. Alex Z

    Alex Z Well-Known Member

    Сообщения:
    138
    Симпатии:
    1
    Баллы:
    61
    Лекс
    Чтобы понять, что программить под Cell трудно, не обязательно надо быть программистом. Достаточно прочитать то, что пишут сами создатели Cell’а.
    Пример с перемножением матриц:
    Как будут выглядеть эти 7 строк, соптимизированные для работы на SPE? Ответ:


    /* @(#)86 1.3 src/workloads/matrix_mul/spu/block.c, sw.workloads, sdk_pub 10/11/05 15:29:21 */
    /* -------------------------------------------------------------- */
    /* (C) Copyright 2001,2005, */
    /* International Business Machines Corporation, */
    /* Sony Computer Entertainment Incorporated, */
    /* Toshiba Corporation. */
    /* */
    /* All Rights Reserved. */
    /* -------------------------------------------------------------- */
    /* PROLOG END TAG zYx */

    /*
    * Matrix Multiply --- EUC
    *
    * block.c - Matrix Multiply with block partitioning
    */

    #include <spu_intrinsics.h>
    #include <stdlib.h>
    #include <vec_literal.h>
    #include <cbe_mfc.h>
    #include <spu_mfcio.h>
    #include "atomic_inc_return.h"

    #ifndef M
    #define M 64 /* Size of the matrix block - M x M */
    #endif

    #define MAX_N 1024
    #define MAX_TILES (MAX_N / M)

    static unsigned int N;
    static unsigned int ITER;
    static unsigned int A_AREA, B_AREA, C_AREA;
    static atomic_ea_t FINC_AREA2;

    #define DIN_TAG 0
    #define DOUT_TAG 2

    #define DMA_Wait(TAG_ID)
    {
    mfc_write_tag_mask((1<<(TAG_ID)));
    mfc_read_tag_status_all();
    }

    #define SwapInBuf()
    {
    OpA = InTag ? blkA1 : blkA0;
    OpB = InTag ? blkB1 : blkB0;
    InTag ^= 1;
    InA = InTag ? blkA1 : blkA0;
    InB = InTag ? blkB1 : blkB0;
    }

    #define SwapOutBuf()
    {
    OpC = (OutTag==DOUT_TAG) ? blkC1 : blkC0;
    OutC = (OutTag==DOUT_TAG) ? blkC1 : blkC0;
    OutTag ^= 1;
    }

    #ifdef _XLC

    #define ALIGN8B
    #define SPU_FMA(RT,RA,RB,RC) RT = spu_madd(RA, RB, RC)
    #define SPU_FM(RT,RA,RB) RT = spu_mul(RA, RB)
    #define SPU_LNOP

    #else

    #define ALIGN8B asm volatile(".align 3")

    #define SPU_FMA(RT,RA,RB,RC)
    asm volatile(".align 3");
    asm volatile("fma %0,%1,%2,%3":"=r"(RT):"r"(RA),"r"(RB),"r"(RC))

    #define SPU_FM(RT,RA,RB)
    asm volatile(".align 3");
    asm volatile("fm %0,%1,%2":"=r"(RT):"r"(RA),"r"(RB))

    #define SPU_LNOP asm volatile("lnop")


    #endif



    #define StageCBAclr(OFFSET)
    {
    ALIGN8B;
    SPU_FM(c0_0B,a00,b0_0B);
    SPU_FM(c1_0B,a10,b0_0B);
    SPU_FM(c2_0B,a20,b0_0B);
    SPU_FM(c3_0B,a30,b0_0B);
    SPU_FM(c0_1B,a00,b0_1B);
    SPU_FM(c1_1B,a10,b0_1B);
    SPU_FM(c2_1B,a20,b0_1B);
    SPU_FM(c3_1B,a30,b0_1B);
    SPU_FMA(c0_0B,a01,b1_0B,c0_0B);
    SPU_FMA(c1_0B,a11,b1_0B,c1_0B);
    SPU_FMA(c2_0B,a21,b1_0B,c2_0B); b0_0C = *((volatile vector float *)(ptrB+OFFSET+16));
    SPU_FMA(c3_0B,a31,b1_0B,c3_0B); SPU_LNOP;
    SPU_FMA(c0_1B,a01,b1_1B,c0_1B); b1_0C = *((volatile vector float *)(ptrB+M+OFFSET+16));
    SPU_FMA(c1_1B,a11,b1_1B,c1_1B); b2_0C = *((volatile vector float *)(ptrB+2*M+OFFSET+16));
    SPU_FMA(c2_1B,a21,b1_1B,c2_1B); b3_0C = *((volatile vector float *)(ptrB+3*M+OFFSET+16));
    SPU_FMA(c3_1B,a31,b1_1B,c3_1B); SPU_LNOP;
    SPU_FMA(c0_0B,a02,b2_0B,c0_0B); b0_1C = *((volatile vector float *)(ptrB+OFFSET+20));
    SPU_FMA(c1_0B,a12,b2_0B,c1_0B); b1_1C = *((volatile vector float *)(ptrB+M+OFFSET+20));
    SPU_FMA(c2_0B,a22,b2_0B,c2_0B); b2_1C = *((volatile vector float *)(ptrB+2*M+OFFSET+20));
    SPU_FMA(c3_0B,a32,b2_0B,c3_0B); SPU_LNOP;
    SPU_FMA(c0_1B,a02,b2_1B,c0_1B); b3_1C = *((volatile vector float *)(ptrB+3*M+OFFSET+20));
    SPU_FMA(c1_1B,a12,b2_1B,c1_1B); *((volatile vector float *)(ptrC+OFFSET)) = c0_0A;
    SPU_FMA(c2_1B,a22,b2_1B,c2_1B); *((volatile vector float *)(ptrC+M+OFFSET)) = c1_0A;
    SPU_FMA(c3_1B,a32,b2_1B,c3_1B); SPU_LNOP;
    SPU_FMA(c0_0B,a03,b3_0B,c0_0B); *((volatile vector float *)(ptrC+2*M+OFFSET)) = c2_0A;
    SPU_FMA(c1_0B,a13,b3_0B,c1_0B); *((volatile vector float *)(ptrC+3*M+OFFSET)) = c3_0A;
    SPU_FMA(c2_0B,a23,b3_0B,c2_0B); *((volatile vector float *)(ptrC+OFFSET+4)) = c0_1A;
    SPU_FMA(c3_0B,a33,b3_0B,c3_0B); SPU_LNOP;
    SPU_FMA(c0_1B,a03,b3_1B,c0_1B); *((volatile vector float *)(ptrC+M+OFFSET+4)) = c1_1A;
    SPU_FMA(c1_1B,a13,b3_1B,c1_1B); *((volatile vector float *)(ptrC+2*M+OFFSET+4)) = c2_1A;
    SPU_FMA(c2_1B,a23,b3_1B,c2_1B); *((volatile vector float *)(ptrC+3*M+OFFSET+4)) = c3_1A;
    SPU_FMA(c3_1B,a33,b3_1B,c3_1B); SPU_LNOP;
    }

    #define StageACBclr(OFFSET)
    {
    SPU_FM(c0_0C,a00,b0_0C);
    SPU_FM(c1_0C,a10,b0_0C);
    SPU_FM(c2_0C,a20,b0_0C);
    SPU_FM(c3_0C,a30,b0_0C);
    SPU_FM(c0_1C,a00,b0_1C);
    SPU_FM(c1_1C,a10,b0_1C);
    SPU_FM(c2_1C,a20,b0_1C);
    SPU_FM(c3_1C,a30,b0_1C);
    SPU_FMA(c0_0C,a01,b1_0C,c0_0C);
    SPU_FMA(c1_0C,a11,b1_0C,c1_0C);
    SPU_FMA(c2_0C,a21,b1_0C,c2_0C); b0_0A = *((volatile vector float *)(ptrB+OFFSET+16));
    SPU_FMA(c3_0C,a31,b1_0C,c3_0C); SPU_LNOP;
    SPU_FMA(c0_1C,a01,b1_1C,c0_1C); b1_0A = *((volatile vector float *)(ptrB+M+OFFSET+16));
    SPU_FMA(c1_1C,a11,b1_1C,c1_1C); b2_0A = *((volatile vector float *)(ptrB+2*M+OFFSET+16));
    SPU_FMA(c2_1C,a21,b1_1C,c2_1C); b3_0A = *((volatile vector float *)(ptrB+3*M+OFFSET+16));
    SPU_FMA(c3_1C,a31,b1_1C,c3_1C); SPU_LNOP;
    SPU_FMA(c0_0C,a02,b2_0C,c0_0C); b0_1A = *((volatile vector float *)(ptrB+OFFSET+20));
    SPU_FMA(c1_0C,a12,b2_0C,c1_0C); b1_1A = *((volatile vector float *)(ptrB+M+OFFSET+20));
    SPU_FMA(c2_0C,a22,b2_0C,c2_0C); b2_1A = *((volatile vector float *)(ptrB+2*M+OFFSET+20));
    SPU_FMA(c3_0C,a32,b2_0C,c3_0C); SPU_LNOP;
    SPU_FMA(c0_1C,a02,b2_1C,c0_1C); b3_1A = *((volatile vector float *)(ptrB+3*M+OFFSET+20));
    SPU_FMA(c1_1C,a12,b2_1C,c1_1C); *((volatile vector float *)(ptrC+OFFSET)) = c0_0B;
    SPU_FMA(c2_1C,a22,b2_1C,c2_1C); *((volatile vector float *)(ptrC+M+OFFSET)) = c1_0B;
    SPU_FMA(c3_1C,a32,b2_1C,c3_1C); SPU_LNOP;
    SPU_FMA(c0_0C,a03,b3_0C,c0_0C); *((volatile vector float *)(ptrC+2*M+OFFSET)) = c2_0B;
    SPU_FMA(c1_0C,a13,b3_0C,c1_0C); *((volatile vector float *)(ptrC+3*M+OFFSET)) = c3_0B;
    SPU_FMA(c2_0C,a23,b3_0C,c2_0C); *((volatile vector float *)(ptrC+OFFSET+4)) = c0_1B;
    SPU_FMA(c3_0C,a33,b3_0C,c3_0C); SPU_LNOP;
    SPU_FMA(c0_1C,a03,b3_1C,c0_1C); *((volatile vector float *)(ptrC+M+OFFSET+4)) = c1_1B;
    SPU_FMA(c1_1C,a13,b3_1C,c1_1C); *((volatile vector float *)(ptrC+2*M+OFFSET+4)) = c2_1B;
    SPU_FMA(c2_1C,a23,b3_1C,c2_1C); *((volatile vector float *)(ptrC+3*M+OFFSET+4)) = c3_1B;
    SPU_FMA(c3_1C,a33,b3_1C,c3_1C); SPU_LNOP;
    }

    #define StageBACclr(OFFSET)
    {
    SPU_FM(c0_0A,a00,b0_0A);
    SPU_FM(c1_0A,a10,b0_0A);
    SPU_FM(c2_0A,a20,b0_0A);
    SPU_FM(c3_0A,a30,b0_0A);
    SPU_FM(c0_1A,a00,b0_1A);
    SPU_FM(c1_1A,a10,b0_1A);
    SPU_FM(c2_1A,a20,b0_1A);
    SPU_FM(c3_1A,a30,b0_1A);
    SPU_FMA(c0_0A,a01,b1_0A,c0_0A);
    SPU_FMA(c1_0A,a11,b1_0A,c1_0A);
    SPU_FMA(c2_0A,a21,b1_0A,c2_0A); b0_0B = *((volatile vector float *)(ptrB+OFFSET+16));
    SPU_FMA(c3_0A,a31,b1_0A,c3_0A); SPU_LNOP;
    SPU_FMA(c0_1A,a01,b1_1A,c0_1A); b1_0B = *((volatile vector float *)(ptrB+M+OFFSET+16));
    SPU_FMA(c1_1A,a11,b1_1A,c1_1A); b2_0B = *((volatile vector float *)(ptrB+2*M+OFFSET+16));
    SPU_FMA(c2_1A,a21,b1_1A,c2_1A); b3_0B = *((volatile vector float *)(ptrB+3*M+OFFSET+16));
    SPU_FMA(c3_1A,a31,b1_1A,c3_1A); SPU_LNOP;
    SPU_FMA(c0_0A,a02,b2_0A,c0_0A); b0_1B = *((volatile vector float *)(ptrB+OFFSET+20));
    SPU_FMA(c1_0A,a12,b2_0A,c1_0A); b1_1B = *((volatile vector float *)(ptrB+M+OFFSET+20));
    SPU_FMA(c2_0A,a22,b2_0A,c2_0A); b2_1B = *((volatile vector float *)(ptrB+2*M+OFFSET+20));
    SPU_FMA(c3_0A,a32,b2_0A,c3_0A); SPU_LNOP;
    SPU_FMA(c0_1A,a02,b2_1A,c0_1A); b3_1B = *((volatile vector float *)(ptrB+3*M+OFFSET+20));
    SPU_FMA(c1_1A,a12,b2_1A,c1_1A); *((volatile vector float *)(ptrC+OFFSET)) = c0_0C;
    SPU_FMA(c2_1A,a22,b2_1A,c2_1A); *((volatile vector float *)(ptrC+M+OFFSET)) = c1_0C;
    SPU_FMA(c3_1A,a32,b2_1A,c3_1A); SPU_LNOP;
    SPU_FMA(c0_0A,a03,b3_0A,c0_0A); *((volatile vector float *)(ptrC+2*M+OFFSET)) = c2_0C;
    SPU_FMA(c1_0A,a13,b3_0A,c1_0A); *((volatile vector float *)(ptrC+3*M+OFFSET)) = c3_0C;
    SPU_FMA(c2_0A,a23,b3_0A,c2_0A); *((volatile vector float *)(ptrC+OFFSET+4)) = c0_1C;
    SPU_FMA(c3_0A,a33,b3_0A,c3_0A); SPU_LNOP;
    SPU_FMA(c0_1A,a03,b3_1A,c0_1A); *((volatile vector float *)(ptrC+M+OFFSET+4)) = c1_1C;
    SPU_FMA(c1_1A,a13,b3_1A,c1_1A); *((volatile vector float *)(ptrC+2*M+OFFSET+4)) = c2_1C;
    SPU_FMA(c2_1A,a23,b3_1A,c2_1A); *((volatile vector float *)(ptrC+3*M+OFFSET+4)) = c3_1C;
    SPU_FMA(c3_1A,a33,b3_1A,c3_1A); SPU_LNOP;
    }

    #define StageCBA(OFFSET,OFFB)
    {
    ALIGN8B;
    SPU_FMA(c0_0B,a00,b0_0B,c0_0B); c0_0C = *((volatile vector float *)(ptrC+OFFSET+16));
    SPU_FMA(c1_0B,a10,b0_0B,c1_0B); c1_0C = *((volatile vector float *)(ptrC+M+OFFSET+16));
    SPU_FMA(c2_0B,a20,b0_0B,c2_0B); c2_0C = *((volatile vector float *)(ptrC+2*M+OFFSET+16));
    SPU_FMA(c3_0B,a30,b0_0B,c3_0B); SPU_LNOP;
    SPU_FMA(c0_1B,a00,b0_1B,c0_1B); c3_0C = *((volatile vector float *)(ptrC+3*M+OFFSET+16));
    SPU_FMA(c1_1B,a10,b0_1B,c1_1B); c0_1C = *((volatile vector float *)(ptrC+OFFSET+20));
    SPU_FMA(c2_1B,a20,b0_1B,c2_1B); c1_1C = *((volatile vector float *)(ptrC+M+OFFSET+20));
    SPU_FMA(c3_1B,a30,b0_1B,c3_1B); SPU_LNOP;
    SPU_FMA(c0_0B,a01,b1_0B,c0_0B); c2_1C = *((volatile vector float *)(ptrC+2*M+OFFSET+20));
    SPU_FMA(c1_0B,a11,b1_0B,c1_0B); c3_1C = *((volatile vector float *)(ptrC+3*M+OFFSET+20));
    SPU_FMA(c2_0B,a21,b1_0B,c2_0B); b0_0C = *((volatile vector float *)(ptrB+OFFSET+OFFB*M+16));
    SPU_FMA(c3_0B,a31,b1_0B,c3_0B); SPU_LNOP;
    SPU_FMA(c0_1B,a01,b1_1B,c0_1B); b1_0C = *((volatile vector float *)(ptrB+M+OFFSET+OFFB*M+16));
    SPU_FMA(c1_1B,a11,b1_1B,c1_1B); b2_0C = *((volatile vector float *)(ptrB+2*M+OFFSET+OFFB*M+16));
    SPU_FMA(c2_1B,a21,b1_1B,c2_1B); b3_0C = *((volatile vector float *)(ptrB+3*M+OFFSET+OFFB*M+16));
    SPU_FMA(c3_1B,a31,b1_1B,c3_1B); SPU_LNOP;
    SPU_FMA(c0_0B,a02,b2_0B,c0_0B); b0_1C = *((volatile vector float *)(ptrB+OFFSET+OFFB*M+20));
    SPU_FMA(c1_0B,a12,b2_0B,c1_0B); b1_1C = *((volatile vector float *)(ptrB+M+OFFSET+OFFB*M+20));
    SPU_FMA(c2_0B,a22,b2_0B,c2_0B); b2_1C = *((volatile vector float *)(ptrB+2*M+OFFSET+OFFB*M+20));
    SPU_FMA(c3_0B,a32,b2_0B,c3_0B); SPU_LNOP;
    SPU_FMA(c0_1B,a02,b2_1B,c0_1B); b3_1C = *((volatile vector float *)(ptrB+3*M+OFFSET+OFFB*M+20));
    SPU_FMA(c1_1B,a12,b2_1B,c1_1B); *((volatile vector float *)(ptrC+OFFSET)) = c0_0A;
    SPU_FMA(c2_1B,a22,b2_1B,c2_1B); *((volatile vector float *)(ptrC+M+OFFSET)) = c1_0A;
    SPU_FMA(c3_1B,a32,b2_1B,c3_1B); SPU_LNOP;
    SPU_FMA(c0_0B,a03,b3_0B,c0_0B); *((volatile vector float *)(ptrC+2*M+OFFSET)) = c2_0A;
    SPU_FMA(c1_0B,a13,b3_0B,c1_0B); *((volatile vector float *)(ptrC+3*M+OFFSET)) = c3_0A;
    SPU_FMA(c2_0B,a23,b3_0B,c2_0B); *((volatile vector float *)(ptrC+OFFSET+4)) = c0_1A;
    SPU_FMA(c3_0B,a33,b3_0B,c3_0B); SPU_LNOP;
    SPU_FMA(c0_1B,a03,b3_1B,c0_1B); *((volatile vector float *)(ptrC+M+OFFSET+4)) = c1_1A;
    SPU_FMA(c1_1B,a13,b3_1B,c1_1B); *((volatile vector float *)(ptrC+2*M+OFFSET+4)) = c2_1A;
    SPU_FMA(c2_1B,a23,b3_1B,c2_1B); *((volatile vector float *)(ptrC+3*M+OFFSET+4)) = c3_1A;
    SPU_FMA(c3_1B,a33,b3_1B,c3_1B); SPU_LNOP;
    }

    #define StageCBAmod(OFFSET,OFFB)
    {
    ALIGN8B;
    SPU_FMA(c0_0B,a00,b0_0B,c0_0B); SPU_LNOP;
    SPU_FMA(c1_0B,a10,b0_0B,c1_0B); b2_0B = *((volatile vector float *)(ptrB+2*M+OFFB*M+8 ));
    SPU_FMA(c2_0B,a20,b0_0B,c2_0B); b2_1B = *((volatile vector float *)(ptrB+2*M+OFFB*M+12));
    SPU_FMA(c3_0B,a30,b0_0B,c3_0B); b3_0B = *((volatile vector float *)(ptrB+3*M+OFFB*M+8 ));
    SPU_FMA(c0_1B,a00,b0_1B,c0_1B); b3_1B = *((volatile vector float *)(ptrB+3*M+OFFB*M+12));
    SPU_FMA(c1_1B,a10,b0_1B,c1_1B); c0_0C = *((volatile vector float *)(ptrC+OFFSET+16));
    SPU_FMA(c2_1B,a20,b0_1B,c2_1B); c1_0C = *((volatile vector float *)(ptrC+M+OFFSET+16));
    SPU_FMA(c3_1B,a30,b0_1B,c3_1B); c2_0C = *((volatile vector float *)(ptrC+2*M+OFFSET+16));
    SPU_FMA(c0_0B,a01,b1_0B,c0_0B); c3_0C = *((volatile vector float *)(ptrC+3*M+OFFSET+16));
    SPU_FMA(c1_0B,a11,b1_0B,c1_0B); SPU_LNOP;
    SPU_FMA(c2_0B,a21,b1_0B,c2_0B); c0_1C = *((volatile vector float *)(ptrC+OFFSET+20));
    SPU_FMA(c3_0B,a31,b1_0B,c3_0B); c1_1C = *((volatile vector float *)(ptrC+M+OFFSET+20));
    SPU_FMA(c0_1B,a01,b1_1B,c0_1B); c2_1C = *((volatile vector float *)(ptrC+2*M+OFFSET+20));
    SPU_FMA(c1_1B,a11,b1_1B,c1_1B); c3_1C = *((volatile vector float *)(ptrC+3*M+OFFSET+20));
    SPU_FMA(c2_1B,a21,b1_1B,c2_1B); b0_0C = *((volatile vector float *)(ptrB+OFFSET+OFFB*M+16));
    SPU_FMA(c3_1B,a31,b1_1B,c3_1B); b1_0C = *((volatile vector float *)(ptrB+M+OFFSET+OFFB*M+16));
    SPU_FMA(c0_0B,a02,b2_0B,c0_0B); b2_0C = *((volatile vector float *)(ptrB+2*M+OFFSET+OFFB*M+16));
    SPU_FMA(c1_0B,a12,b2_0B,c1_0B); b3_0C = *((volatile vector float *)(ptrB+3*M+OFFSET+OFFB*M+16));
    SPU_FMA(c2_0B,a22,b2_0B,c2_0B); SPU_LNOP;
    SPU_FMA(c3_0B,a32,b2_0B,c3_0B); b0_1C = *((volatile vector float *)(ptrB+OFFSET+OFFB*M+20));
    SPU_FMA(c0_1B,a02,b2_1B,c0_1B); b1_1C = *((volatile vector float *)(ptrB+M+OFFSET+OFFB*M+20));
    SPU_FMA(c1_1B,a12,b2_1B,c1_1B); b2_1C = *((volatile vector float *)(ptrB+2*M+OFFSET+OFFB*M+20));
    SPU_FMA(c2_1B,a22,b2_1B,c2_1B); b3_1C = *((volatile vector float *)(ptrB+3*M+OFFSET+OFFB*M+20));
    SPU_FMA(c3_1B,a32,b2_1B,c3_1B); *((volatile vector float *)(ptrC+OFFSET)) = c0_0A;
    SPU_FMA(c0_0B,a03,b3_0B,c0_0B); *((volatile vector float *)(ptrC+M+OFFSET)) = c1_0A;
    SPU_FMA(c1_0B,a13,b3_0B,c1_0B); *((volatile vector float *)(ptrC+2*M+OFFSET)) = c2_0A;
    SPU_FMA(c2_0B,a23,b3_0B,c2_0B); *((volatile vector float *)(ptrC+3*M+OFFSET)) = c3_0A;
    SPU_FMA(c3_0B,a33,b3_0B,c3_0B); SPU_LNOP;
    SPU_FMA(c0_1B,a03,b3_1B,c0_1B); *((volatile vector float *)(ptrC+OFFSET+4)) = c0_1A;
    SPU_FMA(c1_1B,a13,b3_1B,c1_1B); *((volatile vector float *)(ptrC+M+OFFSET+4)) = c1_1A;
    SPU_FMA(c2_1B,a23,b3_1B,c2_1B); *((volatile vector float *)(ptrC+2*M+OFFSET+4)) = c2_1A;
    SPU_FMA(c3_1B,a33,b3_1B,c3_1B); *((volatile vector float *)(ptrC+3*M+OFFSET+4)) = c3_1A;
    }

    #define StageACB(OFFSET,OFFB)
    {
    SPU_FMA(c0_0C,a00,b0_0C,c0_0C); c0_0A = *((volatile vector float *)(ptrC+OFFSET+16));
    SPU_FMA(c1_0C,a10,b0_0C,c1_0C); c1_0A = *((volatile vector float *)(ptrC+M+OFFSET+16));
    SPU_FMA(c2_0C,a20,b0_0C,c2_0C); c2_0A = *((volatile vector float *)(ptrC+2*M+OFFSET+16));
    SPU_FMA(c3_0C,a30,b0_0C,c3_0C); SPU_LNOP;
    SPU_FMA(c0_1C,a00,b0_1C,c0_1C); c3_0A = *((volatile vector float *)(ptrC+3*M+OFFSET+16));
    SPU_FMA(c1_1C,a10,b0_1C,c1_1C); c0_1A = *((volatile vector float *)(ptrC+OFFSET+20));
    SPU_FMA(c2_1C,a20,b0_1C,c2_1C); c1_1A = *((volatile vector float *)(ptrC+M+OFFSET+20));
    SPU_FMA(c3_1C,a30,b0_1C,c3_1C); SPU_LNOP;
    SPU_FMA(c0_0C,a01,b1_0C,c0_0C); c2_1A = *((volatile vector float *)(ptrC+2*M+OFFSET+20));
    SPU_FMA(c1_0C,a11,b1_0C,c1_0C); c3_1A = *((volatile vector float *)(ptrC+3*M+OFFSET+20));
    SPU_FMA(c2_0C,a21,b1_0C,c2_0C); b0_0A = *((volatile vector float *)(ptrB+OFFSET+OFFB*M+16));
    SPU_FMA(c3_0C,a31,b1_0C,c3_0C); SPU_LNOP;
    SPU_FMA(c0_1C,a01,b1_1C,c0_1C); b1_0A = *((volatile vector float *)(ptrB+M+OFFSET+OFFB*M+16));
    SPU_FMA(c1_1C,a11,b1_1C,c1_1C); b2_0A = *((volatile vector float *)(ptrB+2*M+OFFSET+OFFB*M+16));
    SPU_FMA(c2_1C,a21,b1_1C,c2_1C); b3_0A = *((volatile vector float *)(ptrB+3*M+OFFSET+OFFB*M+16));
    SPU_FMA(c3_1C,a31,b1_1C,c3_1C); SPU_LNOP;
    SPU_FMA(c0_0C,a02,b2_0C,c0_0C); b0_1A = *((volatile vector float *)(ptrB+OFFSET+OFFB*M+20));
    SPU_FMA(c1_0C,a12,b2_0C,c1_0C); b1_1A = *((volatile vector float *)(ptrB+M+OFFSET+OFFB*M+20));
    SPU_FMA(c2_0C,a22,b2_0C,c2_0C); b2_1A = *((volatile vector float *)(ptrB+2*M+OFFSET+OFFB*M+20));
    SPU_FMA(c3_0C,a32,b2_0C,c3_0C); SPU_LNOP;
    SPU_FMA(c0_1C,a02,b2_1C,c0_1C); b3_1A = *((volatile vector float *)(ptrB+3*M+OFFSET+OFFB*M+20));
    SPU_FMA(c1_1C,a12,b2_1C,c1_1C); *((volatile vector float *)(ptrC+OFFSET)) = c0_0B;
    SPU_FMA(c2_1C,a22,b2_1C,c2_1C); *((volatile vector float *)(ptrC+M+OFFSET)) = c1_0B;
    SPU_FMA(c3_1C,a32,b2_1C,c3_1C); SPU_LNOP;
    SPU_FMA(c0_0C,a03,b3_0C,c0_0C); *((volatile vector float *)(ptrC+2*M+OFFSET)) = c2_0B;
    SPU_FMA(c1_0C,a13,b3_0C,c1_0C); *((volatile vector float *)(ptrC+3*M+OFFSET)) = c3_0B;
    SPU_FMA(c2_0C,a23,b3_0C,c2_0C); *((volatile vector float *)(ptrC+OFFSET+4)) = c0_1B;
    SPU_FMA(c3_0C,a33,b3_0C,c3_0C); SPU_LNOP;
    SPU_FMA(c0_1C,a03,b3_1C,c0_1C); *((volatile vector float *)(ptrC+M+OFFSET+4)) = c1_1B;
    SPU_FMA(c1_1C,a13,b3_1C,c1_1C); *((volatile vector float *)(ptrC+2*M+OFFSET+4)) = c2_1B;
    SPU_FMA(c2_1C,a23,b3_1C,c2_1C); *((volatile vector float *)(ptrC+3*M+OFFSET+4)) = c3_1B;
    SPU_FMA(c3_1C,a33,b3_1C,c3_1C); SPU_LNOP;
    }

    #define StageBAC(OFFSET,OFFB)
    {
    SPU_FMA(c0_0A,a00,b0_0A,c0_0A); c0_0B = *((volatile vector float *)(ptrC+OFFSET+16));
    SPU_FMA(c1_0A,a10,b0_0A,c1_0A); c1_0B = *((volatile vector float *)(ptrC+M+OFFSET+16));
    SPU_FMA(c2_0A,a20,b0_0A,c2_0A); c2_0B = *((volatile vector float *)(ptrC+2*M+OFFSET+16));
    SPU_FMA(c3_0A,a30,b0_0A,c3_0A); SPU_LNOP;
    SPU_FMA(c0_1A,a00,b0_1A,c0_1A); c3_0B = *((volatile vector float *)(ptrC+3*M+OFFSET+16));
    SPU_FMA(c1_1A,a10,b0_1A,c1_1A); c0_1B = *((volatile vector float *)(ptrC+OFFSET+20));
    SPU_FMA(c2_1A,a20,b0_1A,c2_1A); c1_1B = *((volatile vector float *)(ptrC+M+OFFSET+20));
    SPU_FMA(c3_1A,a30,b0_1A,c3_1A); SPU_LNOP;
    SPU_FMA(c0_0A,a01,b1_0A,c0_0A); c2_1B = *((volatile vector float *)(ptrC+2*M+OFFSET+20));
    SPU_FMA(c1_0A,a11,b1_0A,c1_0A); c3_1B = *((volatile vector float *)(ptrC+3*M+OFFSET+20));
    SPU_FMA(c2_0A,a21,b1_0A,c2_0A); b0_0B = *((volatile vector float *)(ptrB+OFFSET+OFFB*M+16));
    SPU_FMA(c3_0A,a31,b1_0A,c3_0A); SPU_LNOP;
    SPU_FMA(c0_1A,a01,b1_1A,c0_1A); b1_0B = *((volatile vector float *)(ptrB+M+OFFSET+OFFB*M+16));
    SPU_FMA(c1_1A,a11,b1_1A,c1_1A); b2_0B = *((volatile vector float *)(ptrB+2*M+OFFSET+OFFB*M+16));
    SPU_FMA(c2_1A,a21,b1_1A,c2_1A); b3_0B = *((volatile vector float *)(ptrB+3*M+OFFSET+OFFB*M+16));
    SPU_FMA(c3_1A,a31,b1_1A,c3_1A); SPU_LNOP;
    SPU_FMA(c0_0A,a02,b2_0A,c0_0A); b0_1B = *((volatile vector float *)(ptrB+OFFSET+OFFB*M+20));
    SPU_FMA(c1_0A,a12,b2_0A,c1_0A); b1_1B = *((volatile vector float *)(ptrB+M+OFFSET+OFFB*M+20));
    SPU_FMA(c2_0A,a22,b2_0A,c2_0A); b2_1B = *((volatile vector float *)(ptrB+2*M+OFFSET+OFFB*M+20));
    SPU_FMA(c3_0A,a32,b2_0A,c3_0A); SPU_LNOP;
    SPU_FMA(c0_1A,a02,b2_1A,c0_1A); b3_1B = *((volatile vector float *)(ptrB+3*M+OFFSET+OFFB*M+20));
    SPU_FMA(c1_1A,a12,b2_1A,c1_1A); *((volatile vector float *)(ptrC+OFFSET)) = c0_0C;
    SPU_FMA(c2_1A,a22,b2_1A,c2_1A); *((volatile vector float *)(ptrC+M+OFFSET)) = c1_0C;
    SPU_FMA(c3_1A,a32,b2_1A,c3_1A); SPU_LNOP;
    SPU_FMA(c0_0A,a03,b3_0A,c0_0A); *((volatile vector float *)(ptrC+2*M+OFFSET)) = c2_0C;
    SPU_FMA(c1_0A,a13,b3_0A,c1_0A); *((volatile vector float *)(ptrC+3*M+OFFSET)) = c3_0C;
    SPU_FMA(c2_0A,a23,b3_0A,c2_0A); *((volatile vector float *)(ptrC+OFFSET+4)) = c0_1C;
    SPU_FMA(c3_0A,a33,b3_0A,c3_0A); SPU_LNOP;
    SPU_FMA(c0_1A,a03,b3_1A,c0_1A); *((volatile vector float *)(ptrC+M+OFFSET+4)) = c1_1C;
    SPU_FMA(c1_1A,a13,b3_1A,c1_1A); *((volatile vector float *)(ptrC+2*M+OFFSET+4)) = c2_1C;
    SPU_FMA(c2_1A,a23,b3_1A,c2_1A); *((volatile vector float *)(ptrC+3*M+OFFSET+4)) = c3_1C;
    SPU_FMA(c3_1A,a33,b3_1A,c3_1A); SPU_LNOP;
    }

    #define StageMISC(OFFA,OFFB)
    {
    SPU_FMA(c0_0B,a00,b0_0B,c0_0B); a0 = *((volatile vector float *)(ptrA+OFFA+4));
    SPU_FMA(c1_0B,a10,b0_0B,c1_0B); a1 = *((volatile vector float *)(ptrA+M+OFFA+4));
    SPU_FMA(c2_0B,a20,b0_0B,c2_0B); a2 = *((volatile vector float *)(ptrA+2*M+OFFA+4));
    SPU_FMA(c3_0B,a30,b0_0B,c3_0B); a3 = *((volatile vector float *)(ptrA+3*M+OFFA+4));
    SPU_FMA(c0_1B,a00,b0_1B,c0_1B); *((volatile vector float *)(ptrC+48 )) = c0_0A;
    SPU_FMA(c1_1B,a10,b0_1B,c1_1B); *((volatile vector float *)(ptrC+M+48 )) = c1_0A;
    SPU_FMA(c2_1B,a20,b0_1B,c2_1B); a00 = spu_shuffle(a0, a0, pat0);
    SPU_FMA(c3_1B,a30,b0_1B,c3_1B); *((volatile vector float *)(ptrC+2*M+48 )) = c2_0A;
    SPU_FMA(c0_0B,a01,b1_0B,c0_0B); *((volatile vector float *)(ptrC+3*M+48 )) = c3_0A;
    SPU_FMA(c1_0B,a11,b1_0B,c1_0B); a10 = spu_shuffle(a1, a1, pat0);
    SPU_FMA(c2_0B,a21,b1_0B,c2_0B); *((volatile vector float *)(ptrC+52)) = c0_1A;
    SPU_FMA(c3_0B,a31,b1_0B,c3_0B); *((volatile vector float *)(ptrC+M+52)) = c1_1A;
    SPU_FMA(c0_1B,a01,b1_1B,c0_1B); a20 = spu_shuffle(a2, a2, pat0);
    SPU_FMA(c1_1B,a11,b1_1B,c1_1B); *((volatile vector float *)(ptrC+2*M+52)) = c2_1A;
    SPU_FMA(c2_1B,a21,b1_1B,c2_1B); *((volatile vector float *)(ptrC+3*M+52)) = c3_1A;
    SPU_FMA(c3_1B,a31,b1_1B,c3_1B); a30 = spu_shuffle(a3, a3, pat0);
    SPU_FMA(c0_0B,a02,b2_0B,c0_0B); c0_0A = *((volatile vector float *)(ptrC));
    SPU_FMA(c1_0B,a12,b2_0B,c1_0B); c1_0A = *((volatile vector float *)(ptrC+M));
    SPU_FMA(c2_0B,a22,b2_0B,c2_0B); a01 = spu_shuffle(a0, a0, pat1);
    SPU_FMA(c3_0B,a32,b2_0B,c3_0B); c2_0A = *((volatile vector float *)(ptrC+2*M));
    SPU_FMA(c0_1B,a02,b2_1B,c0_1B); c3_0A = *((volatile vector float *)(ptrC+3*M));
    SPU_FMA(c1_1B,a12,b2_1B,c1_1B); a11 = spu_shuffle(a1, a1, pat1);
    SPU_FMA(c2_1B,a22,b2_1B,c2_1B); b0_0A = *((volatile vector float *)(ptrB+4*M+OFFB*M));
    SPU_FMA(c3_1B,a32,b2_1B,c3_1B); b0_1A = *((volatile vector float *)(ptrB+4*M+OFFB*M+4));
    SPU_FMA(c0_0B,a03,b3_0B,c0_0B); a21 = spu_shuffle(a2, a2, pat1);
    SPU_FMA(c1_0B,a13,b3_0B,c1_0B); b1_0A = *((volatile vector float *)(ptrB+5*M+OFFB*M));
    SPU_FMA(c2_0B,a23,b3_0B,c2_0B); b1_1A = *((volatile vector float *)(ptrB+5*M+OFFB*M+4));
    SPU_FMA(c3_0B,a33,b3_0B,c3_0B); a31 = spu_shuffle(a3, a3, pat1);
    SPU_FMA(c0_1B,a03,b3_1B,c0_1B); c0_1A = *((volatile vector float *)(ptrC+4));
    SPU_FMA(c1_1B,a13,b3_1B,c1_1B); c1_1A = *((volatile vector float *)(ptrC+M+4));
    SPU_FMA(c2_1B,a23,b3_1B,c2_1B); a02 = spu_shuffle(a0, a0, pat2);
    SPU_FMA(c3_1B,a33,b3_1B,c3_1B); c2_1A = *((volatile vector float *)(ptrC+2*M+4));
    SPU_FMA(c0_0A,a00,b0_0A,c0_0A); c3_1A = *((volatile vector float *)(ptrC+3*M+4));
    SPU_FMA(c1_0A,a10,b0_0A,c1_0A); a12 = spu_shuffle(a1, a1, pat2);
    SPU_FMA(c2_0A,a20,b0_0A,c2_0A); b2_0A = *((volatile vector float *)(ptrB+6*M+OFFB*M));
    SPU_FMA(c3_0A,a30,b0_0A,c3_0A); b2_1A = *((volatile vector float *)(ptrB+6*M+OFFB*M+4));
    SPU_FMA(c0_1A,a00,b0_1A,c0_1A); a22 = spu_shuffle(a2, a2, pat2);
    SPU_FMA(c1_1A,a10,b0_1A,c1_1A); b3_0A = *((volatile vector float *)(ptrB+7*M+OFFB*M));
    SPU_FMA(c2_1A,a20,b0_1A,c2_1A); b3_1A = *((volatile vector float *)(ptrB+7*M+OFFB*M+4));
    SPU_FMA(c3_1A,a30,b0_1A,c3_1A); a32 = spu_shuffle(a3, a3, pat2);
    SPU_FMA(c0_0A,a01,b1_0A,c0_0A); *((volatile vector float *)(ptrC+56)) = c0_0B;
    SPU_FMA(c1_0A,a11,b1_0A,c1_0A); *((volatile vector float *)(ptrC+M+56)) = c1_0B;
    SPU_FMA(c2_0A,a21,b1_0A,c2_0A); a03 = spu_shuffle(a0, a0, pat3);
    SPU_FMA(c3_0A,a31,b1_0A,c3_0A); *((volatile vector float *)(ptrC+2*M+56)) = c2_0B;
    SPU_FMA(c0_1A,a01,b1_1A,c0_1A); *((volatile vector float *)(ptrC+3*M+56)) = c3_0B;
    SPU_FMA(c1_1A,a11,b1_1A,c1_1A); a13 = spu_shuffle(a1, a1, pat3);
    SPU_FMA(c2_1A,a21,b1_1A,c2_1A); *((volatile vector float *)(ptrC+60)) = c0_1B;
    SPU_FMA(c3_1A,a31,b1_1A,c3_1A); *((volatile vector float *)(ptrC+M+60)) = c1_1B;
    SPU_FMA(c0_0A,a02,b2_0A,c0_0A); a23 = spu_shuffle(a2, a2, pat3);
    SPU_FMA(c1_0A,a12,b2_0A,c1_0A); *((volatile vector float *)(ptrC+2*M+60)) = c2_1B;
    SPU_FMA(c2_0A,a22,b2_0A,c2_0A); *((volatile vector float *)(ptrC+3*M+60)) = c3_1B;
    SPU_FMA(c3_0A,a32,b2_0A,c3_0A); a33 = spu_shuffle(a3, a3, pat3);
    SPU_FMA(c0_1A,a02,b2_1A,c0_1A); b0_0B = *((volatile vector float *)(ptrB+4*M+OFFB*M+8 ));
    SPU_FMA(c1_1A,a12,b2_1A,c1_1A); b0_1B = *((volatile vector float *)(ptrB+4*M+OFFB*M+12));
    SPU_FMA(c2_1A,a22,b2_1A,c2_1A); b1_0B = *((volatile vector float *)(ptrB+5*M+OFFB*M+8 ));
    SPU_FMA(c3_1A,a32,b2_1A,c3_1A); b1_1B = *((volatile vector float *)(ptrB+5*M+OFFB*M+12));
    SPU_FMA(c0_0A,a03,b3_0A,c0_0A); c0_0B = *((volatile vector float *)(ptrC+8 ));
    SPU_FMA(c1_0A,a13,b3_0A,c1_0A); c1_0B = *((volatile vector float *)(ptrC+M+8 ));
    SPU_FMA(c2_0A,a23,b3_0A,c2_0A); c2_0B = *((volatile vector float *)(ptrC+2*M+8 ));
    SPU_FMA(c3_0A,a33,b3_0A,c3_0A); c3_0B = *((volatile vector float *)(ptrC+3*M+8 ));
    SPU_FMA(c0_1A,a03,b3_1A,c0_1A); c0_1B = *((volatile vector float *)(ptrC+12));
    SPU_FMA(c1_1A,a13,b3_1A,c1_1A); c1_1B = *((volatile vector float *)(ptrC+M+12));
    SPU_FMA(c2_1A,a23,b3_1A,c2_1A); c2_1B = *((volatile vector float *)(ptrC+2*M+12));
    SPU_FMA(c3_1A,a33,b3_1A,c3_1A); c3_1B = *((volatile vector float *)(ptrC+3*M+12));
    }

    #define StageMISCmod(OFFA,OFFB)
    {
    SPU_FMA(c0_0B,a00,b0_0B,c0_0B); a0 = *((volatile vector float *)(ptrA+OFFA+4));
    SPU_FMA(c1_0B,a10,b0_0B,c1_0B); a1 = *((volatile vector float *)(ptrA+M+OFFA+4));
    SPU_FMA(c2_0B,a20,b0_0B,c2_0B); a2 = *((volatile vector float *)(ptrA+2*M+OFFA+4));
    SPU_FMA(c3_0B,a30,b0_0B,c3_0B); a3 = *((volatile vector float *)(ptrA+3*M+OFFA+4));
    SPU_FMA(c0_1B,a00,b0_1B,c0_1B); *((volatile vector float *)(ptrC+48 )) = c0_0A;
    SPU_FMA(c1_1B,a10,b0_1B,c1_1B); *((volatile vector float *)(ptrC+M+48 )) = c1_0A;
    SPU_FMA(c2_1B,a20,b0_1B,c2_1B); a00 = spu_shuffle(a0, a0, pat0);
    SPU_FMA(c3_1B,a30,b0_1B,c3_1B); *((volatile vector float *)(ptrC+2*M+48 )) = c2_0A;
    SPU_FMA(c0_0B,a01,b1_0B,c0_0B); *((volatile vector float *)(ptrC+3*M+48 )) = c3_0A;
    SPU_FMA(c1_0B,a11,b1_0B,c1_0B); a10 = spu_shuffle(a1, a1, pat0);
    SPU_FMA(c2_0B,a21,b1_0B,c2_0B); *((volatile vector float *)(ptrC+52)) = c0_1A;
    SPU_FMA(c3_0B,a31,b1_0B,c3_0B); *((volatile vector float *)(ptrC+M+52)) = c1_1A;
    SPU_FMA(c0_1B,a01,b1_1B,c0_1B); a20 = spu_shuffle(a2, a2, pat0);
    SPU_FMA(c1_1B,a11,b1_1B,c1_1B); *((volatile vector float *)(ptrC+2*M+52)) = c2_1A;
    SPU_FMA(c2_1B,a21,b1_1B,c2_1B); *((volatile vector float *)(ptrC+3*M+52)) = c3_1A;
    SPU_FMA(c3_1B,a31,b1_1B,c3_1B); a30 = spu_shuffle(a3, a3, pat0);
    SPU_FMA(c0_0B,a02,b2_0B,c0_0B); c0_0A = *((volatile vector float *)(ptrC));
    SPU_FMA(c1_0B,a12,b2_0B,c1_0B); c1_0A = *((volatile vector float *)(ptrC+M));
    SPU_FMA(c2_0B,a22,b2_0B,c2_0B); a01 = spu_shuffle(a0, a0, pat1);
    SPU_FMA(c3_0B,a32,b2_0B,c3_0B); c2_0A = *((volatile vector float *)(ptrC+2*M));
    SPU_FMA(c0_1B,a02,b2_1B,c0_1B); c3_0A = *((volatile vector float *)(ptrC+3*M));
    SPU_FMA(c1_1B,a12,b2_1B,c1_1B); a11 = spu_shuffle(a1, a1, pat1);
    SPU_FMA(c2_1B,a22,b2_1B,c2_1B); b0_0A = *((volatile vector float *)(ptrB+4*M+OFFB*M));
    SPU_FMA(c3_1B,a32,b2_1B,c3_1B); b0_1A = *((volatile vector float *)(ptrB+4*M+OFFB*M+4));
    SPU_FMA(c0_0B,a03,b3_0B,c0_0B); a21 = spu_shuffle(a2, a2, pat1);
    SPU_FMA(c1_0B,a13,b3_0B,c1_0B); b1_0A = *((volatile vector float *)(ptrB+5*M+OFFB*M));
    SPU_FMA(c2_0B,a23,b3_0B,c2_0B); b1_1A = *((volatile vector float *)(ptrB+5*M+OFFB*M+4));
    SPU_FMA(c3_0B,a33,b3_0B,c3_0B); a31 = spu_shuffle(a3, a3, pat1);
    SPU_FMA(c0_1B,a03,b3_1B,c0_1B); c0_1A = *((volatile vector float *)(ptrC+4));
    SPU_FMA(c1_1B,a13,b3_1B,c1_1B); c1_1A = *((volatile vector float *)(ptrC+M+4));
    SPU_FMA(c2_1B,a23,b3_1B,c2_1B); a02 = spu_shuffle(a0, a0, pat2);
    SPU_FMA(c3_1B,a33,b3_1B,c3_1B); c2_1A = *((volatile vector float *)(ptrC+2*M+4));
    SPU_FMA(c0_0A,a00,b0_0A,c0_0A); c3_1A = *((volatile vector float *)(ptrC+3*M+4));
    SPU_FMA(c1_0A,a10,b0_0A,c1_0A); a12 = spu_shuffle(a1, a1, pat2);
    SPU_FMA(c2_0A,a20,b0_0A,c2_0A); b2_0A = *((volatile vector float *)(ptrB+6*M+OFFB*M));
    SPU_FMA(c3_0A,a30,b0_0A,c3_0A); b2_1A = *((volatile vector float *)(ptrB+6*M+OFFB*M+4));
    SPU_FMA(c0_1A,a00,b0_1A,c0_1A); a22 = spu_shuffle(a2, a2, pat2);
    SPU_FMA(c1_1A,a10,b0_1A,c1_1A); b3_0A = *((volatile vector float *)(ptrB+7*M+OFFB*M));
    SPU_FMA(c2_1A,a20,b0_1A,c2_1A); b3_1A = *((volatile vector float *)(ptrB+7*M+OFFB*M+4));
    SPU_FMA(c3_1A,a30,b0_1A,c3_1A); a32 = spu_shuffle(a3, a3, pat2);
    SPU_FMA(c0_0A,a01,b1_0A,c0_0A); *((volatile vector float *)(ptrC+56)) = c0_0B;
    SPU_FMA(c1_0A,a11,b1_0A,c1_0A); *((volatile vector float *)(ptrC+M+56)) = c1_0B;
    SPU_FMA(c2_0A,a21,b1_0A,c2_0A); a03 = spu_shuffle(a0, a0, pat3);
    SPU_FMA(c3_0A,a31,b1_0A,c3_0A); *((volatile vector float *)(ptrC+2*M+56)) = c2_0B;
    SPU_FMA(c0_1A,a01,b1_1A,c0_1A); *((volatile vector float *)(ptrC+3*M+56)) = c3_0B;
    SPU_FMA(c1_1A,a11,b1_1A,c1_1A); a13 = spu_shuffle(a1, a1, pat3);
    SPU_FMA(c2_1A,a21,b1_1A,c2_1A); *((volatile vector float *)(ptrC+60)) = c0_1B;
    SPU_FMA(c3_1A,a31,b1_1A,c3_1A); *((volatile vector float *)(ptrC+M+60)) = c1_1B;
    SPU_FMA(c0_0A,a02,b2_0A,c0_0A); a23 = spu_shuffle(a2, a2, pat3);
    SPU_FMA(c1_0A,a12,b2_0A,c1_0A); *((volatile vector float *)(ptrC+2*M+60)) = c2_1B;
    SPU_FMA(c2_0A,a22,b2_0A,c2_0A); *((volatile vector float *)(ptrC+3*M+60)) = c3_1B;
    SPU_FMA(c3_0A,a32,b2_0A,c3_0A); a33 = spu_shuffle(a3, a3, pat3);
    SPU_FMA(c0_1A,a02,b2_1A,c0_1A); b0_0B = *((volatile vector float *)(ptrB+4*M+OFFB*M+8 ));
    SPU_FMA(c1_1A,a12,b2_1A,c1_1A); b0_1B = *((volatile vector float *)(ptrB+4*M+OFFB*M+12));
    SPU_FMA(c2_1A,a22,b2_1A,c2_1A); b1_0B = *((volatile vector float *)(ptrB+5*M+OFFB*M+8 ));
    SPU_FMA(c3_1A,a32,b2_1A,c3_1A); b1_1B = *((volatile vector float *)(ptrB+5*M+OFFB*M+12));
    SPU_FMA(c0_0A,a03,b3_0A,c0_0A); c0_0B = *((volatile vector float *)(ptrC+8 ));
    SPU_FMA(c1_0A,a13,b3_0A,c1_0A); c1_0B = *((volatile vector float *)(ptrC+M+8 ));
    SPU_FMA(c2_0A,a23,b3_0A,c2_0A); c2_0B = *((volatile vector float *)(ptrC+2*M+8 ));
    SPU_FMA(c3_0A,a33,b3_0A,c3_0A); c3_0B = *((volatile vector float *)(ptrC+3*M+8 ));
    SPU_FMA(c0_1A,a03,b3_1A,c0_1A); b2_0B = *((volatile vector float *)(ptrB+6*M+OFFB*M+8 ));
    SPU_FMA(c1_1A,a13,b3_1A,c1_1A); b2_1B = *((volatile vector float *)(ptrB+6*M+OFFB*M+12));
    SPU_FMA(c2_1A,a23,b3_1A,c2_1A); b3_0B = *((volatile vector float *)(ptrB+7*M+OFFB*M+8 ));
    SPU_FMA(c3_1A,a33,b3_1A,c3_1A); b3_1B = *((volatile vector float *)(ptrB+7*M+OFFB*M+12));
    ALIGN8B;
    c0_1B = *((volatile vector float *)(ptrC+12));
    c1_1B = *((volatile vector float *)(ptrC+M+12));
    c2_1B = *((volatile vector float *)(ptrC+2*M+12));
    c3_1B = *((volatile vector float *)(ptrC+3*M+12));
    ptrB += OFFB*M;
    ALIGN8B;
    }

    #define StageMISCclr()
    {
    SPU_FM(c0_0B,a00,b0_0B); a0 = *((volatile vector float *)(ptrA+4));
    SPU_FM(c1_0B,a10,b0_0B); a1 = *((volatile vector float *)(ptrA+M+4));
    SPU_FM(c2_0B,a20,b0_0B); a2 = *((volatile vector float *)(ptrA+2*M+4));
    SPU_FM(c3_0B,a30,b0_0B); a3 = *((volatile vector float *)(ptrA+3*M+4));
    SPU_FM(c0_1B,a00,b0_1B); *((volatile vector float *)(ptrC+48 )) = c0_0A;
    SPU_FM(c1_1B,a10,b0_1B); *((volatile vector float *)(ptrC+M+48 )) = c1_0A;
    SPU_FM(c2_1B,a20,b0_1B); a00 = spu_shuffle(a0, a0, pat0);
    SPU_FM(c3_1B,a30,b0_1B); *((volatile vector float *)(ptrC+2*M+48 )) = c2_0A;
    SPU_FMA(c0_0B,a01,b1_0B,c0_0B); *((volatile vector float *)(ptrC+3*M+48 )) = c3_0A;
    SPU_FMA(c1_0B,a11,b1_0B,c1_0B); a10 = spu_shuffle(a1, a1, pat0);
    SPU_FMA(c2_0B,a21,b1_0B,c2_0B); *((volatile vector float *)(ptrC+52)) = c0_1A;
    SPU_FMA(c3_0B,a31,b1_0B,c3_0B); *((volatile vector float *)(ptrC+M+52)) = c1_1A;
    SPU_FMA(c0_1B,a01,b1_1B,c0_1B); a20 = spu_shuffle(a2, a2, pat0);
    SPU_FMA(c1_1B,a11,b1_1B,c1_1B); *((volatile vector float *)(ptrC+2*M+52)) = c2_1A;
    SPU_FMA(c2_1B,a21,b1_1B,c2_1B); *((volatile vector float *)(ptrC+3*M+52)) = c3_1A;
    SPU_FMA(c3_1B,a31,b1_1B,c3_1B); a30 = spu_shuffle(a3, a3, pat0);
    SPU_FMA(c0_0B,a02,b2_0B,c0_0B); c0_0A = *((volatile vector float *)(ptrC));
    SPU_FMA(c1_0B,a12,b2_0B,c1_0B); c1_0A = *((volatile vector float *)(ptrC+M));
    SPU_FMA(c2_0B,a22,b2_0B,c2_0B); a01 = spu_shuffle(a0, a0, pat1);
    SPU_FMA(c3_0B,a32,b2_0B,c3_0B); c2_0A = *((volatile vector float *)(ptrC+2*M));
    SPU_FMA(c0_1B,a02,b2_1B,c0_1B); c3_0A = *((volatile vector float *)(ptrC+3*M));
    SPU_FMA(c1_1B,a12,b2_1B,c1_1B); a11 = spu_shuffle(a1, a1, pat1);
    SPU_FMA(c2_1B,a22,b2_1B,c2_1B); b0_0A = *((volatile vector float *)(ptrB+4*M));
    SPU_FMA(c3_1B,a32,b2_1B,c3_1B); b0_1A = *((volatile vector float *)(ptrB+4*M+4));
    SPU_FMA(c0_0B,a03,b3_0B,c0_0B); a21 = spu_shuffle(a2, a2, pat1);
    SPU_FMA(c1_0B,a13,b3_0B,c1_0B); b1_0A = *((volatile vector float *)(ptrB+5*M));
    SPU_FMA(c2_0B,a23,b3_0B,c2_0B); b1_1A = *((volatile vector float *)(ptrB+5*M+4));
    SPU_FMA(c3_0B,a33,b3_0B,c3_0B); a31 = spu_shuffle(a3, a3, pat1);
    SPU_FMA(c0_1B,a03,b3_1B,c0_1B); c0_1A = *((volatile vector float *)(ptrC+4));
    SPU_FMA(c1_1B,a13,b3_1B,c1_1B); c1_1A = *((volatile vector float *)(ptrC+M+4));
    SPU_FMA(c2_1B,a23,b3_1B,c2_1B); a02 = spu_shuffle(a0, a0, pat2);
    SPU_FMA(c3_1B,a33,b3_1B,c3_1B); c2_1A = *((volatile vector float *)(ptrC+2*M+4));
    SPU_FMA(c0_0A,a00,b0_0A,c0_0A); c3_1A = *((volatile vector float *)(ptrC+3*M+4));
    SPU_FMA(c1_0A,a10,b0_0A,c1_0A); a12 = spu_shuffle(a1, a1, pat2);
    SPU_FMA(c2_0A,a20,b0_0A,c2_0A); b2_0A = *((volatile vector float *)(ptrB+6*M));
    SPU_FMA(c3_0A,a30,b0_0A,c3_0A); b2_1A = *((volatile vector float *)(ptrB+6*M+4));
    SPU_FMA(c0_1A,a00,b0_1A,c0_1A); a22 = spu_shuffle(a2, a2, pat2);
    SPU_FMA(c1_1A,a10,b0_1A,c1_1A); b3_0A = *((volatile vector float *)(ptrB+7*M));
    SPU_FMA(c2_1A,a20,b0_1A,c2_1A); b3_1A = *((volatile vector float *)(ptrB+7*M+4));
    SPU_FMA(c3_1A,a30,b0_1A,c3_1A); a32 = spu_shuffle(a3, a3, pat2);
    SPU_FMA(c0_0A,a01,b1_0A,c0_0A); *((volatile vector float *)(ptrC+56)) = c0_0B;
    SPU_FMA(c1_0A,a11,b1_0A,c1_0A); *((volatile vector float *)(ptrC+M+56)) = c1_0B;
    SPU_FMA(c2_0A,a21,b1_0A,c2_0A); a03 = spu_shuffle(a0, a0, pat3);
    SPU_FMA(c3_0A,a31,b1_0A,c3_0A); *((volatile vector float *)(ptrC+2*M+56)) = c2_0B;
    SPU_FMA(c0_1A,a01,b1_1A,c0_1A); *((volatile vector float *)(ptrC+3*M+56)) = c3_0B;
    SPU_FMA(c1_1A,a11,b1_1A,c1_1A); a13 = spu_shuffle(a1, a1, pat3);
    SPU_FMA(c2_1A,a21,b1_1A,c2_1A); *((volatile vector float *)(ptrC+60)) = c0_1B;
    SPU_FMA(c3_1A,a31,b1_1A,c3_1A); *((volatile vector float *)(ptrC+M+60)) = c1_1B;
    SPU_FMA(c0_0A,a02,b2_0A,c0_0A); a23 = spu_shuffle(a2, a2, pat3);
    SPU_FMA(c1_0A,a12,b2_0A,c1_0A); *((volatile vector float *)(ptrC+2*M+60)) = c2_1B;
    SPU_FMA(c2_0A,a22,b2_0A,c2_0A); *((volatile vector float *)(ptrC+3*M+60)) = c3_1B;
    SPU_FMA(c3_0A,a32,b2_0A,c3_0A); a33 = spu_shuffle(a3, a3, pat3);
    SPU_FMA(c0_1A,a02,b2_1A,c0_1A); b0_0B = *((volatile vector float *)(ptrB+4*M+8 ));
    SPU_FMA(c1_1A,a12,b2_1A,c1_1A); b0_1B = *((volatile vector float *)(ptrB+4*M+12));
    SPU_FMA(c2_1A,a22,b2_1A,c2_1A); b1_0B = *((volatile vector float *)(ptrB+5*M+8 ));
    SPU_FMA(c3_1A,a32,b2_1A,c3_1A); b1_1B = *((volatile vector float *)(ptrB+5*M+12));
    SPU_FMA(c0_0A,a03,b3_0A,c0_0A); c0_0B = *((volatile vector float *)(ptrC+8 ));
    SPU_FMA(c1_0A,a13,b3_0A,c1_0A); c1_0B = *((volatile vector float *)(ptrC+M+8 ));
    SPU_FMA(c2_0A,a23,b3_0A,c2_0A); c2_0B = *((volatile vector float *)(ptrC+2*M+8 ));
    SPU_FMA(c3_0A,a33,b3_0A,c3_0A); c3_0B = *((volatile vector float *)(ptrC+3*M+8 ));
    SPU_FMA(c0_1A,a03,b3_1A,c0_1A); b2_0B = *((volatile vector float *)(ptrB+6*M+8 ));
    SPU_FMA(c1_1A,a13,b3_1A,c1_1A); b2_1B = *((volatile vector float *)(ptrB+6*M+12));
    SPU_FMA(c2_1A,a23,b3_1A,c2_1A); b3_0B = *((volatile vector float *)(ptrB+7*M+8 ));
    SPU_FMA(c3_1A,a33,b3_1A,c3_1A); b3_1B = *((volatile vector float *)(ptrB+7*M+12));
    ALIGN8B;
    c0_1B = *((volatile vector float *)(ptrC+12));
    c1_1B = *((volatile vector float *)(ptrC+M+12));
    c2_1B = *((volatile vector float *)(ptrC+2*M+12));
    c3_1B = *((volatile vector float *)(ptrC+3*M+12));
    }

    #define Loads4RegSetA(OFFSET)
    {
    c0_0A = *((volatile vector float *)(ptrC+OFFSET));
    c1_0A = *((volatile vector float *)(ptrC+M+OFFSET));
    c2_0A = *((volatile vector float *)(ptrC+2*M+OFFSET));
    c3_0A = *((volatile vector float *)(ptrC+3*M+OFFSET));
    c0_1A = *((volatile vector float *)(ptrC+OFFSET+4));
    c1_1A = *((volatile vector float *)(ptrC+M+OFFSET+4));
    c2_1A = *((volatile vector float *)(ptrC+2*M+OFFSET+4));
    c3_1A = *((volatile vector float *)(ptrC+3*M+OFFSET+4));
    b0_0A = *((volatile vector float *)(ptrB+OFFSET));
    b1_0A = *((volatile vector float *)(ptrB+M+OFFSET));
    b2_0A = *((volatile vector float *)(ptrB+2*M+OFFSET));
    b3_0A = *((volatile vector float *)(ptrB+3*M+OFFSET));
    b0_1A = *((volatile vector float *)(ptrB+OFFSET+4));
    b1_1A = *((volatile vector float *)(ptrB+M+OFFSET+4));
    b2_1A = *((volatile vector float *)(ptrB+2*M+OFFSET+4));
    b3_1A = *((volatile vector float *)(ptrB+3*M+OFFSET+4));
    }

    #define Loads4RegSetAClr(OFFSET)
    {
    b0_0A = *((volatile vector float *)(ptrB+OFFSET));
    b1_0A = *((volatile vector float *)(ptrB+M+OFFSET));
    b2_0A = *((volatile vector float *)(ptrB+2*M+OFFSET));
    b3_0A = *((volatile vector float *)(ptrB+3*M+OFFSET));
    b0_1A = *((volatile vector float *)(ptrB+OFFSET+4));
    b1_1A = *((volatile vector float *)(ptrB+M+OFFSET+4));
    b2_1A = *((volatile vector float *)(ptrB+2*M+OFFSET+4));
    b3_1A = *((volatile vector float *)(ptrB+3*M+OFFSET+4));
    }

    #define Ops4RegSetAClr()
    {
    c0_0A = spu_mul( a00, b0_0A);
    c1_0A = spu_mul( a10, b0_0A);
    c2_0A = spu_mul( a20, b0_0A);
    c3_0A = spu_mul( a30, b0_0A);
    c0_1A = spu_mul( a00, b0_1A);
    c1_1A = spu_mul( a10, b0_1A);
    c2_1A = spu_mul( a20, b0_1A);
    c3_1A = spu_mul( a30, b0_1A);
    c0_0A = spu_madd(a01, b1_0A, c0_0A);
    c1_0A = spu_madd(a11, b1_0A, c1_0A);
    c2_0A = spu_madd(a21, b1_0A, c2_0A);
    c3_0A = spu_madd(a31, b1_0A, c3_0A);
    c0_1A = spu_madd(a01, b1_1A, c0_1A);
    c1_1A = spu_madd(a11, b1_1A, c1_1A);
    c2_1A = spu_madd(a21, b1_1A, c2_1A);
    c3_1A = spu_madd(a31, b1_1A, c3_1A);
    c0_0A = spu_madd(a02, b2_0A, c0_0A);
    c1_0A = spu_madd(a12, b2_0A, c1_0A);
    c2_0A = spu_madd(a22, b2_0A, c2_0A);
    c3_0A = spu_madd(a32, b2_0A, c3_0A);
    c0_1A = spu_madd(a02, b2_1A, c0_1A);
    c1_1A = spu_madd(a12, b2_1A, c1_1A);
    c2_1A = spu_madd(a22, b2_1A, c2_1A);
    c3_1A = spu_madd(a32, b2_1A, c3_1A);
    c0_0A = spu_madd(a03, b3_0A, c0_0A);
    c1_0A = spu_madd(a13, b3_0A, c1_0A);
    c2_0A = spu_madd(a23, b3_0A, c2_0A);
    c3_0A = spu_madd(a33, b3_0A, c3_0A);
    c0_1A = spu_madd(a03, b3_1A, c0_1A);
    c1_1A = spu_madd(a13, b3_1A, c1_1A);
    c2_1A = spu_madd(a23, b3_1A, c2_1A);
    c3_1A = spu_madd(a33, b3_1A, c3_1A);
    }

    #define Ops4RegSetA()
    {
    c0_0A = spu_madd(a00, b0_0A, c0_0A);
    c1_0A = spu_madd(a10, b0_0A, c1_0A);
    c2_0A = spu_madd(a20, b0_0A, c2_0A);
    c3_0A = spu_madd(a30, b0_0A, c3_0A);
    c0_1A = spu_madd(a00, b0_1A, c0_1A);
    c1_1A = spu_madd(a10, b0_1A, c1_1A);
    c2_1A = spu_madd(a20, b0_1A, c2_1A);
    c3_1A = spu_madd(a30, b0_1A, c3_1A);
    c0_0A = spu_madd(a01, b1_0A, c0_0A);
    c1_0A = spu_madd(a11, b1_0A, c1_0A);
    c2_0A = spu_madd(a21, b1_0A, c2_0A);
    c3_0A = spu_madd(a31, b1_0A, c3_0A);
    c0_1A = spu_madd(a01, b1_1A, c0_1A);
    c1_1A = spu_madd(a11, b1_1A, c1_1A);
    c2_1A = spu_madd(a21, b1_1A, c2_1A);
    c3_1A = spu_madd(a31, b1_1A, c3_1A);
    c0_0A = spu_madd(a02, b2_0A, c0_0A);
    c1_0A = spu_madd(a12, b2_0A, c1_0A);
    c2_0A = spu_madd(a22, b2_0A, c2_0A);
    c3_0A = spu_madd(a32, b2_0A, c3_0A);
    c0_1A = spu_madd(a02, b2_1A, c0_1A);
    c1_1A = spu_madd(a12, b2_1A, c1_1A);
    c2_1A = spu_madd(a22, b2_1A, c2_1A);
    c3_1A = spu_madd(a32, b2_1A, c3_1A);
    c0_0A = spu_madd(a03, b3_0A, c0_0A);
    c1_0A = spu_madd(a13, b3_0A, c1_0A);
    c2_0A = spu_madd(a23, b3_0A, c2_0A);
    c3_0A = spu_madd(a33, b3_0A, c3_0A);
    c0_1A = spu_madd(a03, b3_1A, c0_1A);
    c1_1A = spu_madd(a13, b3_1A, c1_1A);
    c2_1A = spu_madd(a23, b3_1A, c2_1A);
    c3_1A = spu_madd(a33, b3_1A, c3_1A);
    }

    #define Stores4RegSetA(OFFSET)
    {
    *((volatile vector float *)(ptrC+OFFSET)) = c0_0A;
    *((volatile vector float *)(ptrC+M+OFFSET)) = c1_0A;
    *((volatile vector float *)(ptrC+2*M+OFFSET)) = c2_0A;
    *((volatile vector float *)(ptrC+3*M+OFFSET)) = c3_0A;
    *((volatile vector float *)(ptrC+OFFSET+4)) = c0_1A;
    *((volatile vector float *)(ptrC+M+OFFSET+4)) = c1_1A;
    *((volatile vector float *)(ptrC+2*M+OFFSET+4)) = c2_1A;
    *((volatile vector float *)(ptrC+3*M+OFFSET+4)) = c3_1A;
    }

    #define Loads4RegSetB(OFFSET)
    {
    c0_0B = *((volatile vector float *)(ptrC+OFFSET));
    c1_0B = *((volatile vector float *)(ptrC+M+OFFSET));
    c2_0B = *((volatile vector float *)(ptrC+2*M+OFFSET));
    c3_0B = *((volatile vector float *)(ptrC+3*M+OFFSET));
    c0_1B = *((volatile vector float *)(ptrC+OFFSET+4));
    c1_1B = *((volatile vector float *)(ptrC+M+OFFSET+4));
    c2_1B = *((volatile vector float *)(ptrC+2*M+OFFSET+4));
    c3_1B = *((volatile vector float *)(ptrC+3*M+OFFSET+4));
    b0_0B = *((volatile vector float *)(ptrB+OFFSET));
    b1_0B = *((volatile vector float *)(ptrB+M+OFFSET));
    b2_0B = *((volatile vector float *)(ptrB+2*M+OFFSET));
    b3_0B = *((volatile vector float *)(ptrB+3*M+OFFSET));
    b0_1B = *((volatile vector float *)(ptrB+OFFSET+4));
    b1_1B = *((volatile vector float *)(ptrB+M+OFFSET+4));
    b2_1B = *((volatile vector float *)(ptrB+2*M+OFFSET+4));
    b3_1B = *((volatile vector float *)(ptrB+3*M+OFFSET+4));
    }

    #define Loads4RegSetBClr(OFFSET)
    {
    b0_0B = *((volatile vector float *)(ptrB+OFFSET));
    b1_0B = *((volatile vector float *)(ptrB+M+OFFSET));
    b2_0B = *((volatile vector float *)(ptrB+2*M+OFFSET));
    b3_0B = *((volatile vector float *)(ptrB+3*M+OFFSET));
    b0_1B = *((volatile vector float *)(ptrB+OFFSET+4));
    b1_1B = *((volatile vector float *)(ptrB+M+OFFSET+4));
    b2_1B = *((volatile vector float *)(ptrB+2*M+OFFSET+4));
    b3_1B = *((volatile vector float *)(ptrB+3*M+OFFSET+4));
    }

    #define Ops4RegSetB()
    {
    c0_0B = spu_madd(a00, b0_0B, c0_0B);
    c1_0B = spu_madd(a10, b0_0B, c1_0B);
    c2_0B = spu_madd(a20, b0_0B, c2_0B);
    c3_0B = spu_madd(a30, b0_0B, c3_0B);
    c0_1B = spu_madd(a00, b0_1B, c0_1B);
    c1_1B = spu_madd(a10, b0_1B, c1_1B);
    c2_1B = spu_madd(a20, b0_1B, c2_1B);
    c3_1B = spu_madd(a30, b0_1B, c3_1B);
    c0_0B = spu_madd(a01, b1_0B, c0_0B);
    c1_0B = spu_madd(a11, b1_0B, c1_0B);
    c2_0B = spu_madd(a21, b1_0B, c2_0B);
    c3_0B = spu_madd(a31, b1_0B, c3_0B);
    c0_1B = spu_madd(a01, b1_1B, c0_1B);
    c1_1B = spu_madd(a11, b1_1B, c1_1B);
    c2_1B = spu_madd(a21, b1_1B, c2_1B);
    c3_1B = spu_madd(a31, b1_1B, c3_1B);
    c0_0B = spu_madd(a02, b2_0B, c0_0B); SPU_LNOP;
    c1_0B = spu_madd(a12, b2_0B, c1_0B);
    c2_0B = spu_madd(a22, b2_0B, c2_0B);
    c3_0B = spu_madd(a32, b2_0B, c3_0B);
    c0_1B = spu_madd(a02, b2_1B, c0_1B);
    c1_1B = spu_madd(a12, b2_1B, c1_1B);
    c2_1B = spu_madd(a22, b2_1B, c2_1B);
    c3_1B = spu_madd(a32, b2_1B, c3_1B);
    c0_0B = spu_madd(a03, b3_0B, c0_0B);
    c1_0B = spu_madd(a13, b3_0B, c1_0B);
    c2_0B = spu_madd(a23, b3_0B, c2_0B);
    c3_0B = spu_madd(a33, b3_0B, c3_0B);
    c0_1B = spu_madd(a03, b3_1B, c0_1B);
    c1_1B = spu_madd(a13, b3_1B, c1_1B);
    c2_1B = spu_madd(a23, b3_1B, c2_1B);
    c3_1B = spu_madd(a33, b3_1B, c3_1B);
    }

    #define Stores4RegSetB(OFFSET)
    {
    *((volatile vector float *)(ptrC+OFFSET)) = c0_0B;
    *((volatile vector float *)(ptrC+M+OFFSET)) = c1_0B;
    *((volatile vector float *)(ptrC+2*M+OFFSET)) = c2_0B;
    *((volatile vector float *)(ptrC+3*M+OFFSET)) = c3_0B;
    *((volatile vector float *)(ptrC+OFFSET+4)) = c0_1B;
    *((volatile vector float *)(ptrC+M+OFFSET+4)) = c1_1B;
    *((volatile vector float *)(ptrC+2*M+OFFSET+4)) = c2_1B;
    *((volatile vector float *)(ptrC+3*M+OFFSET+4)) = c3_1B;
    }

    float blkA0[M*M] __attribute__((aligned(128 )));
    float blkB0[M*M] __attribute__((aligned(128 )));
    float blkC0[M*M] __attribute__((aligned(128 )));
    float blkA1[M*M] __attribute__((aligned(128 )));
    float blkB1[M*M] __attribute__((aligned(128 )));
    float blkC1[M*M] __attribute__((aligned(128 )));

    // For synchronnization
    char lsbuf[128] __attribute__((aligned(128 )));


    static void Block_Fetch(volatile float *blkA, volatile float *blkB,
    unsigned int by, unsigned int bx, unsigned int idx, unsigned int rtag)
    {
    unsigned int baseA, baseB;

    baseA = A_AREA + 4*(by*M*N+idx*M*M);
    baseB = B_AREA + 4*(bx*M*M+idx*M*N);

    mfc_get(blkA, baseA, sizeof(float)*M*M, rtag, 0, 0);
    mfc_get(blkB, baseB, sizeof(float)*M*M, rtag, 0, 0);
    }




    static void MatInit_MxM(volatile float *blkC, volatile float *blkA, volatile float *blkB)
    {
    unsigned int i;
    volatile float *ptrA, *ptrB, *ptrC;

    vector float a0, a1, a2, a3;

    vector float a00, a01, a02, a03;
    vector float a10, a11, a12, a13;
    vector float a20, a21, a22, a23;
    vector float a30, a31, a32, a33;

    vector float b0_0A, b1_0A, b2_0A, b3_0A;
    vector float c0_0A, c1_0A, c2_0A, c3_0A;
    vector float b0_1A, b1_1A, b2_1A, b3_1A;
    vector float c0_1A, c1_1A, c2_1A, c3_1A;

    vector float b0_0B, b1_0B, b2_0B, b3_0B;
    vector float c0_0B, c1_0B, c2_0B, c3_0B;
    vector float b0_1B, b1_1B, b2_1B, b3_1B;
    vector float c0_1B, c1_1B, c2_1B, c3_1B;

    vector float b0_0C, b1_0C, b2_0C, b3_0C;
    vector float c0_0C, c1_0C, c2_0C, c3_0C;
    vector float b0_1C, b1_1C, b2_1C, b3_1C;
    vector float c0_1C, c1_1C, c2_1C, c3_1C;

    const vector unsigned char pat0 = VEC_LITERAL(vector unsigned char,
    0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03,
    0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03);

    const vector unsigned char pat1 = VEC_LITERAL(vector unsigned char,
    0x04, 0x05, 0x06, 0x07, 0x04, 0x05, 0x06, 0x07,
    0x04, 0x05, 0x06, 0x07, 0x04, 0x05, 0x06, 0x07);

    const vector unsigned char pat2 = VEC_LITERAL(vector unsigned char,
    0x08, 0x09, 0x0a, 0x0b, 0x08, 0x09, 0x0a, 0x0b,
    0x08, 0x09, 0x0a, 0x0b, 0x08, 0x09, 0x0a, 0x0b);

    const vector unsigned char pat3 = VEC_LITERAL(vector unsigned char,
    0x0c, 0x0d, 0x0e, 0x0f, 0x0c, 0x0d, 0x0e, 0x0f,
    0x0c, 0x0d, 0x0e, 0x0f, 0x0c, 0x0d, 0x0e, 0x0f);

    for(i=0; i<M; i+=4){
    ptrA = &blkA[i*M];
    ptrB = &blkB[0];
    ptrC = &blkC[i*M];
    a0 = *((volatile vector float *)(ptrA));
    a1 = *((volatile vector float *)(ptrA+M));
    a2 = *((volatile vector float *)(ptrA+2*M));
    a3 = *((volatile vector float *)(ptrA+3*M));
    a00 = spu_shuffle(a0, a0, pat0);
    a01 = spu_shuffle(a0, a0, pat1);
    a02 = spu_shuffle(a0, a0, pat2);
    a03 = spu_shuffle(a0, a0, pat3);
    a10 = spu_shuffle(a1, a1, pat0);
    a11 = spu_shuffle(a1, a1, pat1);
    a12 = spu_shuffle(a1, a1, pat2);
    a13 = spu_shuffle(a1, a1, pat3);
    a20 = spu_shuffle(a2, a2, pat0);
    a21 = spu_shuffle(a2, a2, pat1);
    a22 = spu_shuffle(a2, a2, pat2);
    a23 = spu_shuffle(a2, a2, pat3);
    a30 = spu_shuffle(a3, a3, pat0);
    a31 = spu_shuffle(a3, a3, pat1);
    a32 = spu_shuffle(a3, a3, pat2);
    a33 = spu_shuffle(a3, a3, pat3);
    Loads4RegSetAClr(0);
    Ops4RegSetAClr();
    Loads4RegSetBClr(8 );
    StageCBAclr(0);
    StageACBclr(8 );
    StageBACclr(16);
    StageCBAclr(24);
    StageACBclr(32);
    StageBACclr(40);
    StageMISCclr();
    StageCBA(0,4);
    StageACB(8,4);
    StageBAC(16,4);
    StageCBA(24,4);
    StageACB(32,4);
    StageBAC(40,4);
    StageMISC(4,4);
    StageCBAmod(0,8 );
    StageACB(8,8 );
    StageBAC(16,8 );
    StageCBA(24,8 );
    StageACB(32,8 );
    StageBAC(40,8 );
    StageMISC(8,8 );
    StageCBAmod(0,12);
    StageACB(8,12);
    StageBAC(16,12);
    StageCBA(24,12);
    StageACB(32,12);
    StageBAC(40,12);
    StageMISC(12,12);
    StageCBAmod(0,16);
    StageACB(8,16);
    StageBAC(16,16);
    StageCBA(24,16);
    StageACB(32,16);
    StageBAC(40,16);
    StageMISC(16,16);
    StageCBAmod(0,20);
    StageACB(8,20);
    StageBAC(16,20);
    StageCBA(24,20);
    StageACB(32,20);
    StageBAC(40,20);
    StageMISC(20,20);
    StageCBAmod(0,24);
    StageACB(8,24);
    StageBAC(16,24);
    StageCBA(24,24);
    StageACB(32,24);
    StageBAC(40,24);
    StageMISCmod(24,24);
    StageCBA(0,4);
    StageACB(8,4);
    StageBAC(16,4);
    StageCBA(24,4);
    StageACB(32,4);
    StageBAC(40,4);
    StageMISC(28,4);
    StageCBAmod(0,8 );
    StageACB(8,8 );
    StageBAC(16,8 );
    StageCBA(24,8 );
    StageACB(32,8 );
    StageBAC(40,8 );
    StageMISC(32,8 );
    StageCBAmod(0,12);
    StageACB(8,12);
    StageBAC(16,12);
    StageCBA(24,12);
    StageACB(32,12);
    StageBAC(40,12);
    StageMISC(36,12);
    StageCBAmod(0,16);
    StageACB(8,16);
    StageBAC(16,16);
    StageCBA(24,16);
    StageACB(32,16);
    StageBAC(40,16);
    StageMISC(40,16);
    StageCBAmod(0,20);
    StageACB(8,20);
    StageBAC(16,20);
    StageCBA(24,20);
    StageACB(32,20);
    StageBAC(40,20);
    StageMISC(44,20);
    StageCBAmod(0,24);
    StageACB(8,24);
    StageBAC(16,24);
    StageCBA(24,24);
    StageACB(32,24);
    StageBAC(40,24);
    StageMISCmod(48,24);
    StageCBA(0,4);
    StageACB(8,4);
    StageBAC(16,4);
    StageCBA(24,4);
    StageACB(32,4);
    StageBAC(40,4);
    StageMISC(52,4);
    StageCBAmod(0,8 );
    StageACB(8,8 );
    StageBAC(16,8 );
    StageCBA(24,8 );
    StageACB(32,8 );
    StageBAC(40,8 );
    StageMISC(56,8 );
    StageCBAmod(0,12);
    StageACB(8,12);
    StageBAC(16,12);
    StageCBA(24,12);
    StageACB(32,12);
    StageBAC(40,12);
    Ops4RegSetB();
    Stores4RegSetA(48 );
    Stores4RegSetB(56);
    }
    }

    static void MatMult_MxM(volatile float *blkC, volatile float *blkA, volatile float *blkB)
    {
    unsigned int i;
    volatile float *ptrA, *ptrB, *ptrC;

    vector float a0, a1, a2, a3;

    vector float a00, a01, a02, a03;
    vector float a10, a11, a12, a13;
    vector float a20, a21, a22, a23;
    vector float a30, a31, a32, a33;

    vector float b0_0A, b1_0A, b2_0A, b3_0A;
    vector float c0_0A, c1_0A, c2_0A, c3_0A;
    vector float b0_1A, b1_1A, b2_1A, b3_1A;
    vector float c0_1A, c1_1A, c2_1A, c3_1A;

    vector float b0_0B, b1_0B, b2_0B, b3_0B;
    vector float c0_0B, c1_0B, c2_0B, c3_0B;
    vector float b0_1B, b1_1B, b2_1B, b3_1B;
    vector float c0_1B, c1_1B, c2_1B, c3_1B;

    vector float b0_0C, b1_0C, b2_0C, b3_0C;
    vector float c0_0C, c1_0C, c2_0C, c3_0C;
    vector float b0_1C, b1_1C, b2_1C, b3_1C;
    vector float c0_1C, c1_1C, c2_1C, c3_1C;

    const vector unsigned char pat0 = VEC_LITERAL(vector unsigned char,
    0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03,
    0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 0x03);

    const vector unsigned char pat1 = VEC_LITERAL(vector unsigned char,
    0x04, 0x05, 0x06, 0x07, 0x04, 0x05, 0x06, 0x07,
    0x04, 0x05, 0x06, 0x07, 0x04, 0x05, 0x06, 0x07);

    const vector unsigned char pat2 = VEC_LITERAL(vector unsigned char,
    0x08, 0x09, 0x0a, 0x0b, 0x08, 0x09, 0x0a, 0x0b,
    0x08, 0x09, 0x0a, 0x0b, 0x08, 0x09, 0x0a, 0x0b);

    const vector unsigned char pat3 = VEC_LITERAL(vector unsigned char,
    0x0c, 0x0d, 0x0e, 0x0f, 0x0c, 0x0d, 0x0e, 0x0f,
    0x0c, 0x0d, 0x0e, 0x0f, 0x0c, 0x0d, 0x0e, 0x0f);

    for(i=0; i<M; i+=4){
    ptrA = &blkA[i*M];
    ptrB = &blkB[0];
    ptrC = &blkC[i*M];
    a0 = *((volatile vector float *)(ptrA));
    a1 = *((volatile vector float *)(ptrA+M));
    a2 = *((volatile vector float *)(ptrA+2*M));
    a3 = *((volatile vector float *)(ptrA+3*M));
    a00 = spu_shuffle(a0, a0, pat0);
    a01 = spu_shuffle(a0, a0, pat1);
    a02 = spu_shuffle(a0, a0, pat2);
    a03 = spu_shuffle(a0, a0, pat3);
    a10 = spu_shuffle(a1, a1, pat0);
    a11 = spu_shuffle(a1, a1, pat1);
    a12 = spu_shuffle(a1, a1, pat2);
    a13 = spu_shuffle(a1, a1, pat3);
    a20 = spu_shuffle(a2, a2, pat0);
    a21 = spu_shuffle(a2, a2, pat1);
    a22 = spu_shuffle(a2, a2, pat2);
    a23 = spu_shuffle(a2, a2, pat3);
    a30 = spu_shuffle(a3, a3, pat0);
    a31 = spu_shuffle(a3, a3, pat1);
    a32 = spu_shuffle(a3, a3, pat2);
    a33 = spu_shuffle(a3, a3, pat3);
    Loads4RegSetA(0);
    Ops4RegSetA();
    Loads4RegSetB(8 );
    StageCBA(0,0);
    StageACB(8,0);
    StageBAC(16,0);
    StageCBA(24,0);
    StageACB(32,0);
    StageBAC(40,0);
    StageMISC(0,0);
    StageCBAmod(0,4);
    StageACB(8,4);
    StageBAC(16,4);
    StageCBA(24,4);
    StageACB(32,4);
    StageBAC(40,4);
    StageMISC(4,4);
    StageCBAmod(0,8 );
    StageACB(8,8 );
    StageBAC(16,8 );
    StageCBA(24,8 );
    StageACB(32,8 );
    StageBAC(40,8 );
    StageMISC(8,8 );
    StageCBAmod(0,12);
    StageACB(8,12);
    StageBAC(16,12);
    StageCBA(24,12);
    StageACB(32,12);
    StageBAC(40,12);
    StageMISC(12,12);
    StageCBAmod(0,16);
    StageACB(8,16);
    StageBAC(16,16);
    StageCBA(24,16);
    StageACB(32,16);
    StageBAC(40,16);
    StageMISC(16,16);
    StageCBAmod(0,20);
    StageACB(8,20);
    StageBAC(16,20);
    StageCBA(24,20);
    StageACB(32,20);
    StageBAC(40,20);
    StageMISC(20,20);
    StageCBAmod(0,24);
    StageACB(8,24);
    StageBAC(16,24);
    StageCBA(24,24);
    StageACB(32,24);
    StageBAC(40,24);
    StageMISCmod(24,24);
    StageCBA(0,4);
    StageACB(8,4);
    StageBAC(16,4);
    StageCBA(24,4);
    StageACB(32,4);
    StageBAC(40,4);
    StageMISC(28,4);
    StageCBAmod(0,8 );
    StageACB(8,8 );
    StageBAC(16,8 );
    StageCBA(24,8 );
    StageACB(32,8 );
    StageBAC(40,8 );
    StageMISC(32,8 );
    StageCBAmod(0,12);
    StageACB(8,12);
    StageBAC(16,12);
    StageCBA(24,12);
    StageACB(32,12);
    StageBAC(40,12);
    StageMISC(36,12);
    StageCBAmod(0,16);
    StageACB(8,16);
    StageBAC(16,16);
    StageCBA(24,16);
    StageACB(32,16);
    StageBAC(40,16);
    StageMISC(40,16);
    StageCBAmod(0,20);
    StageACB(8,20);
    StageBAC(16,20);
    StageCBA(24,20);
    StageACB(32,20);
    StageBAC(40,20);
    StageMISC(44,20);
    StageCBAmod(0,24);
    StageACB(8,24);
    StageBAC(16,24);
    StageCBA(24,24);
    StageACB(32,24);
    StageBAC(40,24);
    StageMISCmod(48,24);
    StageCBA(0,4);
    StageACB(8,4);
    StageBAC(16,4);
    StageCBA(24,4);
    StageACB(32,4);
    StageBAC(40,4);
    StageMISC(52,4);
    StageCBAmod(0,8 );
    StageACB(8,8 );
    StageBAC(16,8 );
    StageCBA(24,8 );
    StageACB(32,8 );
    StageBAC(40,8 );
    StageMISC(56,8 );
    StageCBAmod(0,12);
    StageACB(8,12);
    StageBAC(16,12);
    StageCBA(24,12);
    StageACB(32,12);
    StageBAC(40,12);
    Ops4RegSetB();
    Stores4RegSetA(48 );
    Stores4RegSetB(56);
    }
    }


    static void Block_Store(volatile float *blkC, int by, int bx, int wtag)
    {
    unsigned int baseC;

    baseC = C_AREA + 4*(by*M*N+bx*M*M);

    mfc_put(blkC, baseC, sizeof(float)*M*M, wtag, 0, 0);
    }


    int main()
    {
    unsigned int i, j, k;
    unsigned int i_next, j_next;

    volatile float *InA, *InB;
    volatile float *OpA, *OpB, *OpC;
    volatile float *OutC;

    unsigned int InTag = DIN_TAG;
    unsigned int OutTag = DOUT_TAG;

    unsigned int blkid = 0;
    unsigned int shift, mask;
    unsigned int blocks, tiles;

    // Double Buffer Initialization
    InA = blkA0;
    InB = blkB0;
    OpA = blkA0;
    OpB = blkB0;
    OpC = blkC0;
    OutC = blkC0;

    // Fetch working parameters from mailbox. The input
    // parameters include:
    // N = the size of the matrix
    // ITER = number of times to perform matrix multiply
    // FINC_AREA2 = pointer to synchronization counter
    // A_AREA = pointer to input matrix A
    // B_AREA = pointer to input matrix B
    // C_AREA = pointer to output matrix C

    N = spu_read_in_mbox();
    ITER = spu_read_in_mbox();
    FINC_AREA2 = (atomic_ea_t)spu_read_in_mbox();
    A_AREA = spu_read_in_mbox();
    B_AREA = spu_read_in_mbox();
    C_AREA = spu_read_in_mbox();

    tiles = N / M;
    blocks = tiles * tiles;
    mask = tiles - 1;
    shift = 32 - spu_extract(spu_cntlz(spu_promote(mask, 0)), 0);

    // Matrix Multiply with block partitioning
    blkid = _atomic_inc_return(FINC_AREA2);
    i = (blkid >> shift) & mask;
    j = (blkid) & mask;
    if (blkid >= ITER*blocks) exit(0);
    Block_Fetch(InA, InB, i, j, 0, InTag);

    while(1){
    SwapInBuf();
    Block_Fetch(InA, InB, i, j, 1, InTag);
    DMA_Wait(InTag^1);
    DMA_Wait(OutTag);
    MatInit_MxM(OpC, OpA, OpB);
    for(k=1;k<(N/M)-1;k++){
    SwapInBuf();
    Block_Fetch(InA, InB, i, j, k+1, InTag);
    DMA_Wait(InTag^1);
    MatMult_MxM(OpC, OpA, OpB);
    }
    // Epilogue for k==(N/M)-1
    SwapInBuf();

    blkid = _atomic_inc_return(FINC_AREA2);
    i_next = (blkid >> shift) & mask;
    j_next = (blkid) & mask;


    if (blkid >= ITER*blocks) {
    DMA_Wait(InTag^1);
    MatMult_MxM(OpC, OpA, OpB);
    Block_Store(OutC, i, j, OutTag);
    DMA_Wait(OutTag);
    break;
    }

    Block_Fetch(InA, InB, i_next, j_next, 0, InTag);
    DMA_Wait(InTag^1);
    MatMult_MxM(OpC, OpA, OpB);
    Block_Store(OutC, i, j, OutTag);
    i = i_next;
    j = j_next;
    SwapOutBuf();
    }

    return (0);
    }



    Угу, очень легко....
     
  13. Лекс

    Лекс РАЖДЁН, ШТОБ ЖРАТЬ

    Сообщения:
    16.815
    Симпатии:
    550
    Баллы:
    523
    Я думаю, ты чего-то не понял. Не исключено, что речь идёт о разных уровнях языков программирования и всё равно, чтобы судить - обязательно надо быть программистом.
     
  14. DrGonzo

    DrGonzo New Member

    Сообщения:
    1.979
    Симпатии:
    112
    Баллы:
    0
    Да, чтобы оценить подобные заявления, нужно разбираться в предмете. Мне например сложно оценить, насколько адекватно сравнение двух алгоритмов, ибо для меня это темный лес (ну ладно, на Си я бы и сам эту хрень написал, но это сути дела не меняет).
     
  15. EnKoRe

    EnKoRe New Member

    Сообщения:
    5.074
    Симпатии:
    313
    Баллы:
    0
    Дизайн скучный, это первое что меня посетило при виде ps3.
     
  16. DeaD

    DeaD -

    Сообщения:
    2.399
    Симпатии:
    63
    Баллы:
    113
    Ничего себе! :shocking: Бедные разработчики....
     
  17. romka

    romka Очень главный

    Сообщения:
    4.450
    Симпатии:
    184
    Баллы:
    203
    Часть кода выглядит как развёрнутые циклы. Попробуй найти перемножение матриц, оптимизированное под 3DNow, SSE, SSE2 и т.д. и посмотри сколько там строчек. Там конечно будет явно поменьше, чем под SPE, но тоже достаточно. ;)
     
  18. VaaN

    VaaN Stella Maris

    Сообщения:
    20.807
    Симпатии:
    2.230
    Баллы:
    623
    UT2007 не будет стартовым проектом для PS3, так сказал продюссер игры на форуме epic.
    Я так и думал, и я очень рад :)
     
  19. Wendigo

    Wendigo Залип в Elden Ring

    Сообщения:
    9.918
    Симпатии:
    1.607
    Баллы:
    523
    Дизайн довольно строгий и в духе времени. А ты вообще покупаешь технику для обстановки что ли?
     
  20. Alex Z

    Alex Z Well-Known Member

    Сообщения:
    138
    Симпатии:
    1
    Баллы:
    61
    Лекс
    чтобы судить - обязательно надо быть программистом.
    Может быть.
    В общем, я не против Cell'а. Мне нравится, что Sony/IBM/Toshiba создали эффективный процессор для рендеринга, обработки изображения, кодирования аудио/видео; этот процессор идеален для потоковых задач. Только вот что не нравится, это то, что на доводку и отладку технологии Cell уйдёт уйма времени. Т.е. когда программеры начнут "выжимать из него последние капли желудочного сока", придётся ждать долго, возможно несколько лет. Думаю, к 4-му поколению игр увидим что-то близкое к тому, что было в роликах Killzone 2 и Motor Storm'а.
    В любом случае я нисколько не сомневаюсь, что "японские извращенцы" выдавят из Cell'а практически всё, на что он способен. Не сразу, а ближе к концу жизненного цикла консоли. ;)
     
Статус темы:
Закрыта.