499 lines
17 KiB
C
499 lines
17 KiB
C
// Space Taxi -- renderer: the simulation's screen RAM, colour RAM,
|
|
// charset and sprite frame onto the JoeyLib stage.
|
|
//
|
|
// The screen is 40x25 character cells painted from the live charset
|
|
// (the game edits glyphs at runtime: the transporter hatch, the title
|
|
// logo flip-book, the laser beams), one JoeyLib tile per glyph built
|
|
// on a scratch surface and cached by bitmap so an animated glyph is
|
|
// built once per shape. Only the cells the simulation listed as dirty
|
|
// are repainted. The eight VIC sprites are drawn from their bitmaps
|
|
// through a small cache of JoeyLib sprites keyed on (pointer, colour,
|
|
// multicolour mode), with save-under and LIFO restore. Sprite 0 has
|
|
// VIC priority, so the draw order is sprite 7 first, sprite 0 last,
|
|
// and a sprite that has not moved (and has nothing repainted under
|
|
// it) simply stays on the stage: only it and everything drawn after
|
|
// it are undrawn and redrawn when it changes.
|
|
|
|
#include <string.h>
|
|
|
|
#include "spacetaxi.h"
|
|
|
|
#define ST_SPRITE_TILES 3u
|
|
// The IIgs reaches its globals DBR-relative, so all of BSS must fit the
|
|
// entry bank below the I/O window; the caches are sized down there.
|
|
#if defined(__W65816__)
|
|
#define ST_SPRITE_CACHE 24u
|
|
#define ST_CELL_CACHE 24u
|
|
#else
|
|
#define ST_SPRITE_CACHE 72u
|
|
// Pre-coloured cells keyed direct-mapped by character + colours, so a
|
|
// full 256 covers every (char, fg, bg=black) with no collisions.
|
|
#define ST_CELL_CACHE 256u
|
|
#endif
|
|
#define ST_SPRITE_BACKUP_BYTES JOEY_SPRITE_BACKUP_BYTES(ST_SPRITE_TILES, ST_SPRITE_TILES)
|
|
#define ST_SPRITE_PX (8 * ST_SPRITE_TILES)
|
|
|
|
typedef struct {
|
|
jlSpriteT *sprite;
|
|
uint8_t ptr;
|
|
uint8_t color;
|
|
uint8_t multi;
|
|
uint8_t mc0;
|
|
uint8_t mc1;
|
|
uint8_t level; // level index the bitmap came from (level sprites)
|
|
bool used;
|
|
uint32_t lastUse; // for least-recently-used eviction
|
|
} StSpriteCacheT;
|
|
|
|
typedef struct {
|
|
uint8_t bits[8];
|
|
uint8_t fg;
|
|
uint8_t bg;
|
|
jlTileT tile;
|
|
bool used;
|
|
} StCellCacheT;
|
|
|
|
// What is drawn in a draw slot (slot 0 = sprite 7 ... slot 7 = sprite 0).
|
|
typedef struct {
|
|
bool drawn;
|
|
uint16_t x;
|
|
uint8_t y;
|
|
uint8_t ptr;
|
|
uint8_t color;
|
|
uint8_t multi;
|
|
} StDrawnT;
|
|
|
|
typedef struct {
|
|
jlSurfaceT *scratch;
|
|
StCellCacheT cells[ST_CELL_CACHE];
|
|
uint32_t cacheStamp;
|
|
StSpriteCacheT cache[ST_SPRITE_CACHE];
|
|
jlSpriteBackupT backup[ST_HW_SPRITES];
|
|
uint8_t backupMem[ST_HW_SPRITES][ST_SPRITE_BACKUP_BYTES] __attribute__((aligned(2)));
|
|
StDrawnT slot[ST_HW_SPRITES];
|
|
uint8_t lastPresentFrame;
|
|
} StRenderStateT;
|
|
|
|
|
|
static StRenderStateT gRender;
|
|
|
|
// The VIC-II palette in register order, $0RGB.
|
|
static const uint16_t kC64Palette[16] = {
|
|
0x0000, 0x0FFF, 0x0833, 0x06BB, 0x0839, 0x05A4, 0x0438, 0x0BC7,
|
|
0x0852, 0x0540, 0x0B66, 0x0555, 0x0777, 0x09E8, 0x076C, 0x09AA
|
|
};
|
|
|
|
|
|
static jlSpriteT *cachedSprite(StSimT *sim, uint8_t idx);
|
|
static void collectGlyphs(StSimT *sim);
|
|
static void dirtyRect(const StSimT *sim, int16_t *x0, int16_t *y0, int16_t *x1, int16_t *y1);
|
|
static void dropCache(void);
|
|
static void paintCells(jlSurfaceT *stage, StSimT *sim);
|
|
static void pasteCell(jlSurfaceT *stage, const StSimT *sim, uint16_t cell);
|
|
static bool spriteOnScreen(int16_t px, int16_t py);
|
|
|
|
|
|
// The JoeyLib sprite for hardware sprite `idx` of the current frame,
|
|
// built on first use from its VIC bitmap and colours.
|
|
static jlSpriteT *cachedSprite(StSimT *sim, uint8_t idx) {
|
|
uint8_t ptr = sim->frame.ptr[idx];
|
|
uint8_t color = sim->frame.color[idx];
|
|
uint8_t multi = (uint8_t)((sim->frame.multiMask >> idx) & 1u);
|
|
uint8_t mc0 = multi ? sim->spriteMc0 : 0u;
|
|
uint8_t mc1 = multi ? sim->spriteMc1 : 0u;
|
|
uint8_t level = (ptr < ST_SPRITE_PTR_FIRST && sim->level != 0) ? sim->level->levelIndex : 0xFFu;
|
|
const uint8_t *bm;
|
|
StSpriteCacheT *slot = 0;
|
|
uint8_t k;
|
|
uint8_t row;
|
|
|
|
gRender.cacheStamp++;
|
|
for (k = 0u; k < ST_SPRITE_CACHE; k++) {
|
|
StSpriteCacheT *e = &gRender.cache[k];
|
|
if (e->used && e->ptr == ptr && e->color == color && e->multi == multi && e->mc0 == mc0 && e->mc1 == mc1 && e->level == level) {
|
|
e->lastUse = gRender.cacheStamp;
|
|
return e->sprite;
|
|
}
|
|
if (slot == 0 || !e->used || (slot->used && e->used && e->lastUse < slot->lastUse)) {
|
|
if (slot == 0 || !slot->used || !e->used || e->lastUse < slot->lastUse) {
|
|
slot = e;
|
|
}
|
|
}
|
|
}
|
|
if (slot->used) {
|
|
jlSpriteDestroy(slot->sprite);
|
|
slot->sprite = 0;
|
|
slot->used = false;
|
|
}
|
|
bm = stSimSpriteBitmap(sim, ptr);
|
|
jlFillRect(gRender.scratch, 0, 0, ST_SPRITE_PX, ST_SPRITE_PX, 0u);
|
|
if (bm != 0) {
|
|
for (row = 0u; row < ST_SPRITE_H; row++) {
|
|
uint32_t bits = ((uint32_t)bm[row * 3u] << 16) | ((uint32_t)bm[row * 3u + 1u] << 8) | bm[row * 3u + 2u];
|
|
uint8_t x;
|
|
if (multi != 0u) {
|
|
for (x = 0u; x < 12u; x++) {
|
|
uint8_t pair = (uint8_t)((bits >> (22u - x * 2u)) & 3u);
|
|
uint8_t c = 0u;
|
|
if (pair == 1u) {
|
|
c = mc0;
|
|
} else if (pair == 2u) {
|
|
c = color;
|
|
} else if (pair == 3u) {
|
|
c = mc1;
|
|
}
|
|
if (c != 0u) {
|
|
jlDrawPixel(gRender.scratch, (int16_t)(x * 2u), (int16_t)row, c);
|
|
jlDrawPixel(gRender.scratch, (int16_t)(x * 2u + 1u), (int16_t)row, c);
|
|
}
|
|
}
|
|
} else {
|
|
for (x = 0u; x < 24u; x++) {
|
|
if ((bits & (1uL << (23u - x))) != 0u) {
|
|
jlDrawPixel(gRender.scratch, (int16_t)x, (int16_t)row, color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
slot->sprite = jlSpriteCreateFromSurface(gRender.scratch, 0, 0, ST_SPRITE_TILES, ST_SPRITE_TILES);
|
|
if (slot->sprite == 0) {
|
|
return 0;
|
|
}
|
|
// Only the cab, passenger and flame move every tick; the codegen
|
|
// arena is theirs. Everything else stays interpreted (drawn once).
|
|
// Only the cab, exhaust and passenger move every tick; the codegen
|
|
// arena is theirs. Everything else stays interpreted (drawn seldom).
|
|
if (idx <= 2u) {
|
|
(void)jlSpriteCompile(slot->sprite);
|
|
}
|
|
slot->lastUse = gRender.cacheStamp;
|
|
slot->ptr = ptr;
|
|
slot->color = color;
|
|
slot->multi = multi;
|
|
slot->mc0 = mc0;
|
|
slot->mc1 = mc1;
|
|
slot->level = level;
|
|
slot->used = true;
|
|
return slot->sprite;
|
|
}
|
|
|
|
|
|
// A changed glyph (the hatch, the logo flip, the laser beams) makes
|
|
// every cell that shows it dirty; the cell cache self-invalidates on the
|
|
// bitmap compare, so no per-char tile needs rebuilding here.
|
|
static void collectGlyphs(StSimT *sim) {
|
|
uint16_t ch;
|
|
uint16_t cell;
|
|
uint8_t dirty[ST_CHARSET_CHARS];
|
|
bool any = false;
|
|
|
|
for (ch = 0u; ch < ST_CHARSET_CHARS; ch++) {
|
|
dirty[ch] = sim->charDirty[ch];
|
|
if (dirty[ch] != 0u) {
|
|
sim->charDirty[ch] = 0u;
|
|
any = true;
|
|
}
|
|
}
|
|
if (!any || sim->dirtyAll) {
|
|
return;
|
|
}
|
|
for (cell = 0u; cell < ST_SCREEN_CELLS; cell++) {
|
|
if (dirty[sim->screen[cell]] != 0u && sim->cellDirty[cell] == 0u) {
|
|
sim->cellDirty[cell] = 1u;
|
|
if (sim->dirtyCount < (uint8_t)(sizeof(sim->dirtyList) / sizeof(sim->dirtyList[0]))) {
|
|
sim->dirtyList[sim->dirtyCount++] = cell;
|
|
} else {
|
|
sim->dirtyAll = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Bounding box (pixels, x1/y1 exclusive) of the cells about to be
|
|
// repainted. Empty when x1 <= x0.
|
|
static void dirtyRect(const StSimT *sim, int16_t *x0, int16_t *y0, int16_t *x1, int16_t *y1) {
|
|
uint8_t k;
|
|
|
|
if (sim->dirtyAll) {
|
|
*x0 = 0;
|
|
*y0 = 0;
|
|
*x1 = SURFACE_WIDTH;
|
|
*y1 = SURFACE_HEIGHT;
|
|
return;
|
|
}
|
|
*x0 = SURFACE_WIDTH;
|
|
*y0 = SURFACE_HEIGHT;
|
|
*x1 = 0;
|
|
*y1 = 0;
|
|
for (k = 0u; k < sim->dirtyCount; k++) {
|
|
uint16_t cell = sim->dirtyList[k];
|
|
int16_t cx = (int16_t)((cell % ST_SCREEN_COLS) * 8u);
|
|
int16_t cy = (int16_t)((cell / ST_SCREEN_COLS) * 8u);
|
|
if (cx < *x0) {
|
|
*x0 = cx;
|
|
}
|
|
if (cy < *y0) {
|
|
*y0 = cy;
|
|
}
|
|
if ((int16_t)(cx + 8) > *x1) {
|
|
*x1 = (int16_t)(cx + 8);
|
|
}
|
|
if ((int16_t)(cy + 8) > *y1) {
|
|
*y1 = (int16_t)(cy + 8);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void dropCache(void) {
|
|
uint8_t k;
|
|
|
|
for (k = 0u; k < ST_SPRITE_CACHE; k++) {
|
|
if (gRender.cache[k].used) {
|
|
jlSpriteDestroy(gRender.cache[k].sprite);
|
|
gRender.cache[k].sprite = 0;
|
|
gRender.cache[k].used = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Repaint the dirty cells: the list, or everything after an overflow
|
|
// or a scene change.
|
|
static void paintCells(jlSurfaceT *stage, StSimT *sim) {
|
|
uint16_t cell;
|
|
uint8_t k;
|
|
|
|
if (sim->dirtyAll) {
|
|
for (cell = 0u; cell < ST_SCREEN_CELLS; cell++) {
|
|
pasteCell(stage, sim, cell);
|
|
}
|
|
memset(sim->cellDirty, 0, ST_SCREEN_CELLS);
|
|
sim->dirtyCount = 0u;
|
|
sim->dirtyAll = false;
|
|
return;
|
|
}
|
|
for (k = 0u; k < sim->dirtyCount; k++) {
|
|
cell = sim->dirtyList[k];
|
|
pasteCell(stage, sim, cell);
|
|
sim->cellDirty[cell] = 0u;
|
|
}
|
|
sim->dirtyCount = 0u;
|
|
}
|
|
|
|
|
|
// Paste one cell through the coloured-tile cache (direct-mapped on
|
|
// character and colours; an entry is valid while its glyph bits match).
|
|
static void pasteCell(jlSurfaceT *stage, const StSimT *sim, uint16_t cell) {
|
|
uint8_t chr = sim->screen[cell];
|
|
uint8_t fg = sim->color[cell];
|
|
uint8_t bg = sim->bgColor;
|
|
const uint8_t *bits = sim->charset[chr];
|
|
uint8_t bx = (uint8_t)(cell % ST_SCREEN_COLS);
|
|
uint8_t by = (uint8_t)(cell / ST_SCREEN_COLS);
|
|
StCellCacheT *c = &gRender.cells[(uint16_t)(chr + fg * 61u + bg * 7u) % ST_CELL_CACHE];
|
|
|
|
uint8_t row;
|
|
uint8_t bit;
|
|
|
|
if (c->used && c->fg == fg && c->bg == bg && memcmp(c->bits, bits, 8u) == 0) {
|
|
jlTilePaste(stage, bx, by, &c->tile);
|
|
return;
|
|
}
|
|
for (row = 0u; row < 8u; row++) {
|
|
uint8_t b = bits[row];
|
|
for (bit = 0u; bit < 8u; bit++) {
|
|
jlDrawPixel(gRender.scratch, (int16_t)bit, (int16_t)row,
|
|
((b & (uint8_t)(0x80u >> bit)) != 0u) ? fg : bg);
|
|
}
|
|
}
|
|
jlTileSnap(gRender.scratch, 0u, 0u, &c->tile);
|
|
memcpy(c->bits, bits, 8u);
|
|
c->fg = fg;
|
|
c->bg = bg;
|
|
c->used = true;
|
|
jlTilePaste(stage, bx, by, &c->tile);
|
|
}
|
|
|
|
|
|
static bool spriteOnScreen(int16_t px, int16_t py) {
|
|
return px < SURFACE_WIDTH && py < SURFACE_HEIGHT && px > -ST_SPRITE_W && py > -(int16_t)ST_SPRITE_PX;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Public
|
|
// ---------------------------------------------------------------------------
|
|
|
|
void stRenderFrame(jlSurfaceT *stage, StSimT *sim) {
|
|
int16_t dx0;
|
|
int16_t dy0;
|
|
int16_t dx1;
|
|
int16_t dy1;
|
|
uint8_t first = ST_HW_SPRITES;
|
|
uint8_t k;
|
|
|
|
// Find the first draw slot whose sprite changed, vanished, or sits
|
|
// over cells about to be repainted; it and every later slot are
|
|
// undrawn (last first) and redrawn below, the rest stay put.
|
|
collectGlyphs(sim);
|
|
dirtyRect(sim, &dx0, &dy0, &dx1, &dy1);
|
|
for (k = 0u; k < ST_HW_SPRITES; k++) {
|
|
uint8_t idx = (uint8_t)(ST_HW_SPRITES - 1u - k);
|
|
StDrawnT *d = &gRender.slot[k];
|
|
uint8_t multi = (uint8_t)((sim->frame.multiMask >> idx) & 1u);
|
|
int16_t px = (int16_t)((int16_t)sim->frame.x[idx] - ST_SPRITE_X_ORIGIN);
|
|
int16_t py = (int16_t)((int16_t)sim->frame.y[idx] - ST_SPRITE_Y_ORIGIN);
|
|
bool want = (sim->frame.enableMask & (uint8_t)(1u << idx)) != 0u && spriteOnScreen(px, py);
|
|
bool same = (want == d->drawn);
|
|
if (same && want) {
|
|
same = (d->x == sim->frame.x[idx] && d->y == sim->frame.y[idx] && d->ptr == sim->frame.ptr[idx] && d->color == sim->frame.color[idx] && d->multi == multi);
|
|
}
|
|
if (same && want && dx1 > dx0) {
|
|
if (px < dx1 && (int16_t)(px + ST_SPRITE_W) > dx0 && py < dy1 && (int16_t)(py + ST_SPRITE_PX) > dy0) {
|
|
same = false;
|
|
}
|
|
}
|
|
if (!same) {
|
|
first = k;
|
|
break;
|
|
}
|
|
}
|
|
for (k = ST_HW_SPRITES; k > first; k--) {
|
|
StDrawnT *d = &gRender.slot[k - 1u];
|
|
if (d->drawn) {
|
|
jlSpriteRestoreUnder(stage, &gRender.backup[k - 1u]);
|
|
d->drawn = false;
|
|
}
|
|
}
|
|
paintCells(stage, sim);
|
|
for (k = first; k < ST_HW_SPRITES; k++) {
|
|
uint8_t idx = (uint8_t)(ST_HW_SPRITES - 1u - k);
|
|
StDrawnT *d = &gRender.slot[k];
|
|
jlSpriteT *sp;
|
|
int16_t px;
|
|
int16_t py;
|
|
if ((sim->frame.enableMask & (uint8_t)(1u << idx)) == 0u) {
|
|
continue;
|
|
}
|
|
px = (int16_t)((int16_t)sim->frame.x[idx] - ST_SPRITE_X_ORIGIN);
|
|
py = (int16_t)((int16_t)sim->frame.y[idx] - ST_SPRITE_Y_ORIGIN);
|
|
if (!spriteOnScreen(px, py)) {
|
|
continue;
|
|
}
|
|
sp = cachedSprite(sim, idx);
|
|
if (sp == 0) {
|
|
continue;
|
|
}
|
|
jlSpriteSaveAndDraw(stage, sp, px, py, &gRender.backup[k]);
|
|
d->drawn = true;
|
|
d->x = sim->frame.x[idx];
|
|
d->y = sim->frame.y[idx];
|
|
d->ptr = sim->frame.ptr[idx];
|
|
d->color = sim->frame.color[idx];
|
|
d->multi = (uint8_t)((sim->frame.multiMask >> idx) & 1u);
|
|
}
|
|
{
|
|
// Sync to the retrace unless the frame already spans more than
|
|
// one: a late frame goes out at once rather than waiting again.
|
|
uint8_t now = (uint8_t)jlFrameCount();
|
|
if ((uint8_t)(now - gRender.lastPresentFrame) < 2u) {
|
|
jlWaitVBL();
|
|
}
|
|
jlStagePresent();
|
|
gRender.lastPresentFrame = (uint8_t)jlFrameCount();
|
|
}
|
|
}
|
|
|
|
|
|
void stRenderInit(jlSurfaceT *stage) {
|
|
uint8_t k;
|
|
|
|
memset(&gRender, 0, sizeof(gRender));
|
|
for (k = 0u; k < ST_HW_SPRITES; k++) {
|
|
gRender.backup[k].bytes = gRender.backupMem[k];
|
|
}
|
|
jlPaletteSet(stage, 0u, kC64Palette);
|
|
jlScbSetRange(stage, 0u, (uint16_t)(SURFACE_HEIGHT - 1u), 0u);
|
|
jlSurfaceClear(stage, 0u);
|
|
gRender.scratch = jlSurfaceCreate();
|
|
if (gRender.scratch != 0) {
|
|
jlPaletteSet(gRender.scratch, 0u, kC64Palette);
|
|
jlScbSetRange(gRender.scratch, 0u, (uint16_t)(SURFACE_HEIGHT - 1u), 0u);
|
|
jlSurfaceClear(gRender.scratch, 0u);
|
|
}
|
|
}
|
|
|
|
|
|
// Build (and compile) the cels the game draws every screen -- cab,
|
|
// exhaust, passenger, wreck, warp, intro cab and star -- up front, so
|
|
// no frame pays for a sprite build mid-play. A bar on the stage shows
|
|
// progress on the slower ports.
|
|
void stRenderPrewarm(jlSurfaceT *stage, StSimT *sim) {
|
|
static const uint8_t kCabPtrs[] = { 0xC0, 0xC1, 0xDC, 0xDD, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8 };
|
|
static const uint8_t kPassPtrs[] = { 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xD9 };
|
|
static const uint8_t kFlamePtrs[] = { 0xD8, 0xD4, 0xD5, 0xD2, 0xD1, 0xD7, 0xD3, 0xD6 };
|
|
uint8_t total = (uint8_t)(sizeof(kCabPtrs) + sizeof(kPassPtrs) + sizeof(kFlamePtrs) + 1u);
|
|
uint8_t done = 0u;
|
|
uint8_t k;
|
|
StFrameT saved = sim->frame;
|
|
|
|
sim->frame.multiMask = 0x07u;
|
|
sim->spriteMc0 = 0x02u;
|
|
sim->spriteMc1 = 0x07u;
|
|
for (k = 0u; k < sizeof(kCabPtrs); k++) {
|
|
sim->frame.ptr[0] = kCabPtrs[k];
|
|
sim->frame.color[0] = 0x06u;
|
|
(void)cachedSprite(sim, 0u);
|
|
done++;
|
|
jlFillRect(stage, 60, 110, (uint16_t)((uint16_t)done * 200u / total), 6u, 1u);
|
|
jlStagePresent();
|
|
}
|
|
for (k = 0u; k < sizeof(kPassPtrs); k++) {
|
|
sim->frame.ptr[1] = kPassPtrs[k];
|
|
sim->frame.color[1] = 0x06u;
|
|
(void)cachedSprite(sim, 1u);
|
|
done++;
|
|
jlFillRect(stage, 60, 110, (uint16_t)((uint16_t)done * 200u / total), 6u, 1u);
|
|
jlStagePresent();
|
|
}
|
|
for (k = 0u; k < sizeof(kFlamePtrs); k++) {
|
|
sim->frame.ptr[2] = kFlamePtrs[k];
|
|
sim->frame.color[2] = 0x07u;
|
|
(void)cachedSprite(sim, 2u);
|
|
done++;
|
|
jlFillRect(stage, 60, 110, (uint16_t)((uint16_t)done * 200u / total), 6u, 1u);
|
|
jlStagePresent();
|
|
}
|
|
// The intro star is a hires sprite in colour 7 (built, not compiled).
|
|
sim->frame.multiMask = 0u;
|
|
sim->frame.ptr[6] = 0xDAu;
|
|
sim->frame.color[6] = 0x07u;
|
|
(void)cachedSprite(sim, 6u);
|
|
sim->frame = saved;
|
|
jlFillRect(stage, 60, 110, 200u, 6u, 0u);
|
|
}
|
|
|
|
|
|
// A new scene: nothing drawn is valid any more.
|
|
void stRenderSceneChanged(StSimT *sim) {
|
|
uint8_t k;
|
|
|
|
for (k = 0u; k < ST_HW_SPRITES; k++) {
|
|
gRender.slot[k].drawn = false;
|
|
}
|
|
stSimDirtyAll(sim);
|
|
memset(sim->charDirty, 1, ST_CHARSET_CHARS);
|
|
}
|
|
|
|
|
|
void stRenderShutdown(void) {
|
|
dropCache();
|
|
if (gRender.scratch != 0) {
|
|
jlSurfaceDestroy(gRender.scratch);
|
|
gRender.scratch = 0;
|
|
}
|
|
}
|