src/mesa/drivers/dri/r200/r200_tcl.c

   1 /* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_tcl.c,v 1.2 2002/12/16 16:18:55 dawes Exp $ */
   2 /*
   3 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   4
   5 The Weather Channel (TM) funded Tungsten Graphics to develop the
   6 initial release of the Radeon 8500 driver under the XFree86 license.
   7 This notice must be preserved.
   8
   9 Permission is hereby granted, free of charge, to any person obtaining
  10 a copy of this software and associated documentation files (the
  11 "Software"), to deal in the Software without restriction, including
  12 without limitation the rights to use, copy, modify, merge, publish,
  13 distribute, sublicense, and/or sell copies of the Software, and to
  14 permit persons to whom the Software is furnished to do so, subject to
  15 the following conditions:
  16
  17 The above copyright notice and this permission notice (including the
  18 next paragraph) shall be included in all copies or substantial
  19 portions of the Software.
  20
  21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  24 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  25 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28
  29 **************************************************************************/
  30
  31 /*
  32  * Authors:
  33  *   Keith Whitwell <keith@tungstengraphics.com>
  34  */
  35
  36 #include "glheader.h"
  37 #include "imports.h"
  38 #include "mtypes.h"
  39 #include "enums.h"
  40 #include "colormac.h"
  41 #include "light.h"
  42
  43 #include "array_cache/acache.h"
  44 #include "tnl/tnl.h"
  45 #include "tnl/t_pipeline.h"
  46
  47 #include "r200_context.h"
  48 #include "r200_state.h"
  49 #include "r200_ioctl.h"
  50 #include "r200_tex.h"
  51 #include "r200_tcl.h"
  52 #include "r200_swtcl.h"
  53 #include "r200_maos.h"
  54
  55
  56
  57 #define HAVE_POINTS      1
  58 #define HAVE_LINES       1
  59 #define HAVE_LINE_LOOP   0
  60 #define HAVE_LINE_STRIPS 1
  61 #define HAVE_TRIANGLES   1
  62 #define HAVE_TRI_STRIPS  1
  63 #define HAVE_TRI_STRIP_1 0
  64 #define HAVE_TRI_FANS    1
  65 #define HAVE_QUADS       0      /* hw quad verts in wrong order??? */
  66 #define HAVE_QUAD_STRIPS 1
  67 #define HAVE_POLYGONS    1
  68 #define HAVE_ELTS        1
  69
  70
  71 #define HW_POINTS           R200_VF_PRIM_POINTS
  72 #define HW_LINES            R200_VF_PRIM_LINES
  73 #define HW_LINE_LOOP        0
  74 #define HW_LINE_STRIP       R200_VF_PRIM_LINE_STRIP
  75 #define HW_TRIANGLES        R200_VF_PRIM_TRIANGLES
  76 #define HW_TRIANGLE_STRIP_0 R200_VF_PRIM_TRIANGLE_STRIP
  77 #define HW_TRIANGLE_STRIP_1 0
  78 #define HW_TRIANGLE_FAN     R200_VF_PRIM_TRIANGLE_FAN
  79 #define HW_QUADS            R200_VF_PRIM_QUADS
  80 #define HW_QUAD_STRIP       R200_VF_PRIM_QUAD_STRIP
  81 #define HW_POLYGON          R200_VF_PRIM_POLYGON
  82
  83
  84 static GLboolean discrete_prim[0x10] = {
  85    0,                           /* 0 none */
  86    1,                           /* 1 points */
  87    1,                           /* 2 lines */
  88    0,                           /* 3 line_strip */
  89    1,                           /* 4 tri_list */
  90    0,                           /* 5 tri_fan */
  91    0,                           /* 6 tri_strip */
  92    0,                           /* 7 tri_w_flags */
  93    1,                           /* 8 rect list (unused) */
  94    1,                           /* 9 3vert point */
  95    1,                           /* a 3vert line */
  96    0,                           /* b point sprite */
  97    0,                           /* c line loop */
  98    1,                           /* d quads */
  99    0,                           /* e quad strip */
 100    0,                           /* f polygon */
 101 };
 102
 103
 104 #define LOCAL_VARS r200ContextPtr rmesa = R200_CONTEXT(ctx); (void)rmesa
 105 #define ELT_TYPE  GLushort
 106
 107 #define ELT_INIT(prim, hw_prim) \
 108    r200TclPrimitive( ctx, prim, hw_prim | R200_VF_PRIM_WALK_IND )
 109
 110 #define GET_MESA_ELTS() rmesa->tcl.Elts
 111
 112
 113 /* Don't really know how many elts will fit in what's left of cmdbuf,
 114  * as there is state to emit, etc:
 115  */
 116
 117 /* Testing on isosurf shows a maximum around here.  Don't know if it's
 118  * the card or driver or kernel module that is causing the behaviour.
 119  */
 120 #define GET_MAX_HW_ELTS() 300
 121
 122 #define RESET_STIPPLE() do {                    \
 123    R200_STATECHANGE( rmesa, lin );              \
 124    r200EmitState( rmesa );                      \
 125 } while (0)
 126
 127 #define AUTO_STIPPLE( mode )  do {              \
 128    R200_STATECHANGE( rmesa, lin );              \
 129    if (mode)                                    \
 130       rmesa->hw.lin.cmd[LIN_RE_LINE_PATTERN] |= \
 131          R200_LINE_PATTERN_AUTO_RESET;  \
 132    else                                         \
 133       rmesa->hw.lin.cmd[LIN_RE_LINE_PATTERN] &= \
 134          ~R200_LINE_PATTERN_AUTO_RESET; \
 135    r200EmitState( rmesa );                      \
 136 } while (0)
 137
 138
 139 #define ALLOC_ELTS(nr)  r200AllocElts( rmesa, nr )
 140
 141 static GLushort *r200AllocElts( r200ContextPtr rmesa, GLuint nr )
 142 {
 143    if (rmesa->dma.flush == r200FlushElts &&
 144        rmesa->store.cmd_used + nr*2 < R200_CMD_BUF_SZ) {
 145
 146       GLushort *dest = (GLushort *)(rmesa->store.cmd_buf +
 147                                     rmesa->store.cmd_used);
 148
 149       rmesa->store.cmd_used += nr*2;
 150
 151       return dest;
 152    }
 153    else {
 154       if (rmesa->dma.flush)
 155          rmesa->dma.flush( rmesa );
 156
 157       r200EnsureCmdBufSpace( rmesa, AOS_BUFSZ(rmesa->tcl.nr_aos_components) +
 158                              rmesa->hw.max_state_size + ELTS_BUFSZ(nr) );
 159
 160       r200EmitAOS( rmesa,
 161                    rmesa->tcl.aos_components,
 162                    rmesa->tcl.nr_aos_components, 0 );
 163
 164       return r200AllocEltsOpenEnded( rmesa, rmesa->tcl.hw_primitive, nr );
 165    }
 166 }
 167
 168
 169 #define CLOSE_ELTS()                            \
 170 do {                                            \
 171    if (0) R200_NEWPRIM( rmesa );                \
 172 }                                               \
 173 while (0)
 174
 175
 176 /* TODO: Try to extend existing primitive if both are identical,
 177  * discrete and there are no intervening state changes.  (Somewhat
 178  * duplicates changes to DrawArrays code)
 179  */
 180 static void EMIT_PRIM( GLcontext *ctx,
 181                        GLenum prim,
 182                        GLuint hwprim,
 183                        GLuint start,
 184                        GLuint count)
 185 {
 186    r200ContextPtr rmesa = R200_CONTEXT( ctx );
 187    r200TclPrimitive( ctx, prim, hwprim );
 188
 189    r200EnsureCmdBufSpace( rmesa, AOS_BUFSZ(rmesa->tcl.nr_aos_components) +
 190                           rmesa->hw.max_state_size + VBUF_BUFSZ );
 191
 192    r200EmitAOS( rmesa,
 193                   rmesa->tcl.aos_components,
 194                   rmesa->tcl.nr_aos_components,
 195                   start );
 196
 197    /* Why couldn't this packet have taken an offset param?
 198     */
 199    r200EmitVbufPrim( rmesa,
 200                      rmesa->tcl.hw_primitive,
 201                      count - start );
 202 }
 203
 204
 205
 206 /* Try & join small primitives
 207  */
 208 #if 0
 209 #define PREFER_DISCRETE_ELT_PRIM( NR, PRIM ) 0
 210 #else
 211 #define PREFER_DISCRETE_ELT_PRIM( NR, PRIM )                    \
 212   ((NR) < 20 ||                                                 \
 213    ((NR) < 40 &&                                                \
 214     rmesa->tcl.hw_primitive == (PRIM|                           \
 215                             R200_VF_TCL_OUTPUT_VTX_ENABLE|      \
 216                                 R200_VF_PRIM_WALK_IND)))
 217 #endif
 218
 219 #ifdef MESA_BIG_ENDIAN
 220 /* We could do without (most of) this ugliness if dest was always 32 bit word aligned... */
 221 #define EMIT_ELT(dest, offset, x) do {                                \
 222         int off = offset + ( ( (GLuint)dest & 0x2 ) >> 1 );     \
 223         GLushort *des = (GLushort *)( (GLuint)dest & ~0x2 );    \
 224         (des)[ off + 1 - 2 * ( off & 1 ) ] = (GLushort)(x); } while (0)
 225 #else
 226 #define EMIT_ELT(dest, offset, x) (dest)[offset] = (GLushort) (x)
 227 #endif
 228
 229 #define EMIT_TWO_ELTS(dest, offset, x, y)  *(GLuint *)((dest)+offset) = ((y)<<16)|(x);
 230
 231
 232
 233 #define TAG(x) tcl_##x
 234 #include "tnl_dd/t_dd_dmatmp2.h"
 235
 236 /**********************************************************************/
 237 /*                          External entrypoints                     */
 238 /**********************************************************************/
 239
 240 void r200EmitPrimitive( GLcontext *ctx,
 241                           GLuint first,
 242                           GLuint last,
 243                           GLuint flags )
 244 {
 245    tcl_render_tab_verts[flags&PRIM_MODE_MASK]( ctx, first, last, flags );
 246 }
 247
 248 void r200EmitEltPrimitive( GLcontext *ctx,
 249                              GLuint first,
 250                              GLuint last,
 251                              GLuint flags )
 252 {
 253    tcl_render_tab_elts[flags&PRIM_MODE_MASK]( ctx, first, last, flags );
 254 }
 255
 256 void r200TclPrimitive( GLcontext *ctx,
 257                          GLenum prim,
 258                          int hw_prim )
 259 {
 260    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 261    GLuint newprim = hw_prim | R200_VF_TCL_OUTPUT_VTX_ENABLE;
 262
 263    if (newprim != rmesa->tcl.hw_primitive ||
 264        !discrete_prim[hw_prim&0xf]) {
 265       R200_NEWPRIM( rmesa );
 266       rmesa->tcl.hw_primitive = newprim;
 267    }
 268 }
 269
 270
 271 /**********************************************************************/
 272 /*             Fog blend factor computation for hw tcl                */
 273 /*             same calculation used as in t_vb_fog.c                 */
 274 /**********************************************************************/
 275
 276 #define FOG_EXP_TABLE_SIZE 256
 277 #define FOG_MAX (10.0)
 278 #define EXP_FOG_MAX .0006595
 279 #define FOG_INCR (FOG_MAX/FOG_EXP_TABLE_SIZE)
 280 static GLfloat exp_table[FOG_EXP_TABLE_SIZE];
 281
 282 #if 1
 283 #define NEG_EXP( result, narg )                                         \
 284 do {                                                                    \
 285    GLfloat f = (GLfloat) (narg * (1.0/FOG_INCR));                       \
 286    GLint k = (GLint) f;                                                 \
 287    if (k > FOG_EXP_TABLE_SIZE-2)                                        \
 288       result = (GLfloat) EXP_FOG_MAX;                                   \
 289    else                                                                 \
 290       result = exp_table[k] + (f-k)*(exp_table[k+1]-exp_table[k]);      \
 291 } while (0)
 292 #else
 293 #define NEG_EXP( result, narg )                                 \
 294 do {                                                            \
 295    result = exp(-narg);                                         \
 296 } while (0)
 297 #endif
 298
 299
 300 /**
 301  * Initialize the exp_table[] lookup table for approximating exp().
 302  */
 303 void
 304 r200InitStaticFogData( void )
 305 {
 306    GLfloat f = 0.0F;
 307    GLint i = 0;
 308    for ( ; i < FOG_EXP_TABLE_SIZE ; i++, f += FOG_INCR) {
 309       exp_table[i] = (GLfloat) exp(-f);
 310    }
 311 }
 312
 313
 314 /**
 315  * Compute per-vertex fog blend factors from fog coordinates by
 316  * evaluating the GL_LINEAR, GL_EXP or GL_EXP2 fog function.
 317  * Fog coordinates are distances from the eye (typically between the
 318  * near and far clip plane distances).
 319  * Note the fog (eye Z) coords may be negative so we use ABS(z) below.
 320  * Fog blend factors are in the range [0,1].
 321  */
 322 float
 323 r200ComputeFogBlendFactor( GLcontext *ctx, GLfloat fogcoord )
 324 {
 325    GLfloat end  = ctx->Fog.End;
 326    GLfloat d, temp;
 327    const GLfloat z = FABSF(fogcoord);
 328
 329    switch (ctx->Fog.Mode) {
 330    case GL_LINEAR:
 331       if (ctx->Fog.Start == ctx->Fog.End)
 332          d = 1.0F;
 333       else
 334          d = 1.0F / (ctx->Fog.End - ctx->Fog.Start);
 335       temp = (end - z) * d;
 336       return CLAMP(temp, 0.0F, 1.0F);
 337       break;
 338    case GL_EXP:
 339       d = ctx->Fog.Density;
 340       NEG_EXP( temp, d * z );
 341       return temp;
 342       break;
 343    case GL_EXP2:
 344       d = ctx->Fog.Density*ctx->Fog.Density;
 345       NEG_EXP( temp, d * z * z );
 346       return temp;
 347       break;
 348    default:
 349       _mesa_problem(ctx, "Bad fog mode in make_fog_coord");
 350       return 0;
 351    }
 352 }
 353
 354
 355 /**********************************************************************/
 356 /*                          Render pipeline stage                     */
 357 /**********************************************************************/
 358
 359
 360 /* TCL render.
 361  */
 362 static GLboolean r200_run_tcl_render( GLcontext *ctx,
 363                                       struct tnl_pipeline_stage *stage )
 364 {
 365    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 366    TNLcontext *tnl = TNL_CONTEXT(ctx);
 367    struct vertex_buffer *VB = &tnl->vb;
 368    GLuint i;
 369
 370    /* TODO: separate this from the swtnl pipeline
 371     */
 372    if (rmesa->TclFallback)
 373       return GL_TRUE;   /* fallback to software t&l */
 374
 375    if (R200_DEBUG & DEBUG_PRIMS)
 376       fprintf(stderr, "%s\n", __FUNCTION__);
 377
 378    if (VB->Count == 0)
 379       return GL_FALSE;
 380
 381    r200ReleaseArrays( ctx, ~0 /* stage->changed_inputs */ );
 382    r200EmitArrays( ctx, stage->inputs );
 383
 384    rmesa->tcl.Elts = VB->Elts;
 385
 386    for (i = 0 ; i < VB->PrimitiveCount ; i++)
 387    {
 388       GLuint prim = VB->Primitive[i].mode;
 389       GLuint start = VB->Primitive[i].start;
 390       GLuint length = VB->Primitive[i].count;
 391
 392       if (!length)
 393          continue;
 394
 395       if (rmesa->tcl.Elts)
 396          r200EmitEltPrimitive( ctx, start, start+length, prim );
 397       else
 398          r200EmitPrimitive( ctx, start, start+length, prim );
 399    }
 400
 401    return GL_FALSE;             /* finished the pipe */
 402 }
 403
 404
 405
 406 static void r200_check_tcl_render( GLcontext *ctx,
 407                                    struct tnl_pipeline_stage *stage )
 408 {
 409    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 410    GLuint inputs = VERT_BIT_POS;
 411    GLuint unit;
 412
 413    /* Validate state:
 414     */
 415    if (rmesa->NewGLState)
 416       r200ValidateState( ctx );
 417
 418    if (ctx->RenderMode == GL_RENDER) {
 419       /* Make all this event-driven:
 420        */
 421       if (ctx->Light.Enabled) {
 422          inputs |= VERT_BIT_NORMAL;
 423
 424          if (1 || ctx->Light.ColorMaterialEnabled) {
 425             inputs |= VERT_BIT_COLOR0;
 426          }
 427       }
 428       else {
 429          inputs |= VERT_BIT_COLOR0;
 430
 431          if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) {
 432             inputs |= VERT_BIT_COLOR1;
 433          }
 434       }
 435
 436       if ( ctx->Fog.FogCoordinateSource == GL_FOG_COORD ) {
 437          inputs |= VERT_BIT_FOG;
 438       }
 439
 440       for (unit = 0 ; unit < ctx->Const.MaxTextureUnits; unit++) {
 441          if (ctx->Texture.Unit[unit]._ReallyEnabled) {
 442             if (rmesa->TexGenNeedNormals[unit]) {
 443                inputs |= VERT_BIT_NORMAL;
 444             }
 445             inputs |= VERT_BIT_TEX(unit);
 446          }
 447       }
 448
 449       stage->inputs = inputs;
 450       stage->active = 1;
 451    }
 452    else
 453       stage->active = 0;
 454 }
 455
 456 static void r200_init_tcl_render( GLcontext *ctx,
 457                                     struct tnl_pipeline_stage *stage )
 458 {
 459    stage->check = r200_check_tcl_render;
 460    stage->check( ctx, stage );
 461 }
 462
 463 static void dtr( struct tnl_pipeline_stage *stage )
 464 {
 465    (void)stage;
 466 }
 467
 468
 469 /* Initial state for tcl stage.
 470  */
 471 const struct tnl_pipeline_stage _r200_tcl_stage =
 472 {
 473    "r200 render",
 474    (_DD_NEW_SEPARATE_SPECULAR |
 475     _NEW_LIGHT|
 476     _NEW_TEXTURE|
 477     _NEW_FOG|
 478     _NEW_RENDERMODE),           /* re-check (new inputs) */
 479    0,                           /* re-run (always runs) */
 480    GL_TRUE,                     /* active */
 481    0, 0,                        /* inputs (set in check_render), outputs */
 482    0, 0,                        /* changed_inputs, private */
 483    dtr,                         /* destructor */
 484    r200_init_tcl_render,        /* check - initially set to alloc data */
 485    r200_run_tcl_render  /* run */
 486 };
 487
 488
 489
 490 /**********************************************************************/
 491 /*                 Validate state at pipeline start                   */
 492 /**********************************************************************/
 493
 494
 495 /*-----------------------------------------------------------------------
 496  * Manage TCL fallbacks
 497  */
 498
 499
 500 static void transition_to_swtnl( GLcontext *ctx )
 501 {
 502    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 503    TNLcontext *tnl = TNL_CONTEXT(ctx);
 504
 505    R200_NEWPRIM( rmesa );
 506
 507    r200ChooseVertexState( ctx );
 508    r200ChooseRenderState( ctx );
 509
 510    _mesa_validate_all_lighting_tables( ctx );
 511
 512    tnl->Driver.NotifyMaterialChange =
 513       _mesa_validate_all_lighting_tables;
 514
 515    r200ReleaseArrays( ctx, ~0 );
 516
 517    /* Still using the D3D based hardware-rasterizer from the radeon;
 518     * need to put the card into D3D mode to make it work:
 519     */
 520    R200_STATECHANGE( rmesa, vap );
 521    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] &= ~R200_VAP_TCL_ENABLE;
 522 }
 523
 524 static void transition_to_hwtnl( GLcontext *ctx )
 525 {
 526    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 527    TNLcontext *tnl = TNL_CONTEXT(ctx);
 528
 529    _tnl_need_projected_coords( ctx, GL_FALSE );
 530
 531    r200UpdateMaterial( ctx );
 532
 533    tnl->Driver.NotifyMaterialChange = r200UpdateMaterial;
 534
 535    if ( rmesa->dma.flush )
 536       rmesa->dma.flush( rmesa );
 537
 538    rmesa->dma.flush = 0;
 539
 540    if (rmesa->swtcl.indexed_verts.buf)
 541       r200ReleaseDmaRegion( rmesa, &rmesa->swtcl.indexed_verts,
 542                               __FUNCTION__ );
 543
 544    R200_STATECHANGE( rmesa, vap );
 545    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] |= R200_VAP_TCL_ENABLE;
 546    rmesa->hw.vap.cmd[VAP_SE_VAP_CNTL] &= ~R200_VAP_FORCE_W_TO_ONE;
 547
 548    if ( ((rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] & R200_FOG_USE_MASK)
 549       == R200_FOG_USE_SPEC_ALPHA) &&
 550       (ctx->Fog.FogCoordinateSource == GL_FOG_COORD )) {
 551       R200_STATECHANGE( rmesa, ctx );
 552       rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] &= ~R200_FOG_USE_MASK;
 553       rmesa->hw.ctx.cmd[CTX_PP_FOG_COLOR] |= R200_FOG_USE_VTX_FOG;
 554    }
 555
 556    R200_STATECHANGE( rmesa, vte );
 557    rmesa->hw.vte.cmd[VTE_SE_VTE_CNTL] &= ~(R200_VTX_XY_FMT|R200_VTX_Z_FMT);
 558
 559    if (R200_DEBUG & DEBUG_FALLBACKS)
 560       fprintf(stderr, "R200 end tcl fallback\n");
 561 }
 562
 563
 564 static char *fallbackStrings[] = {
 565    "Rasterization fallback",
 566    "Unfilled triangles",
 567    "Twosided lighting, differing materials",
 568    "Materials in VB (maybe between begin/end)",
 569    "Texgen unit 0",
 570    "Texgen unit 1",
 571    "Texgen unit 2",
 572    "Texgen unit 3",
 573    "Texgen unit 4",
 574    "Texgen unit 5",
 575    "User disable",
 576    "Bitmap as points"
 577 };
 578
 579
 580 static char *getFallbackString(GLuint bit)
 581 {
 582    int i = 0;
 583    while (bit > 1) {
 584       i++;
 585       bit >>= 1;
 586    }
 587    return fallbackStrings[i];
 588 }
 589
 590
 591
 592 void r200TclFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
 593 {
 594    r200ContextPtr rmesa = R200_CONTEXT(ctx);
 595    GLuint oldfallback = rmesa->TclFallback;
 596
 597    if (mode) {
 598       rmesa->TclFallback |= bit;
 599       if (oldfallback == 0) {
 600          if (R200_DEBUG & DEBUG_FALLBACKS)
 601             fprintf(stderr, "R200 begin tcl fallback %s\n",
 602                     getFallbackString( bit ));
 603          transition_to_swtnl( ctx );
 604       }
 605    }
 606    else {
 607       rmesa->TclFallback &= ~bit;
 608       if (oldfallback == bit) {
 609          if (R200_DEBUG & DEBUG_FALLBACKS)
 610             fprintf(stderr, "R200 end tcl fallback %s\n",
 611                     getFallbackString( bit ));
 612          transition_to_hwtnl( ctx );
 613       }
 614    }
 615 }