开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
calcdest.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：17k
源码类别：

通讯编程

开发平台：

Visual C++

calcdest.cc：源码内容
  1. extern "C" {
  2. #include <assert.h>
  3. #include <fcntl.h>
  4. #include <math.h>
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <sys/time.h>
  9. #include <sys/types.h>
  10. #include <sys/uio.h>
  11. #include <unistd.h>
  12. /* #include <err.h>*/
  13. };
  14. #include "../../../tools/rng.h"
  15. #include "setdest.h"
  17. //#define DEBUG
  18. #define SANITY_CHECKS
  19. //#define SHOW_SYMMETRIC_PAIRS
  22. #define GOD_FORMAT "$ns_ at %.12f "$god_ set-dist %d %d %d"n"
  23. #define GOD_FORMAT2 "$god_ set-dist %d %d %dn"
  24. #define NODE_FORMAT "$ns_ at %.12f "$node_(%d) setdest %.12f %.12f %.12f"n"
  25. #define NODE_FORMAT2 "$node_(%d) setdest %.12f %.12f %.12fn"
  26. #define NODE_FORMAT3 "$node_(%d) set %c_ %.12fn"
  28. #undef INFINITY
  29. #define INFINITY 0x00ffffff
  30. #define min(x,y) ((x) < (y) ? (x) : (y))
  31. #define max(x,y) ((x) > (y) ? (x) : (y))
  32. #define ROUND_ERROR 1e-9
  34. static int count = 0;
  36. /* ======================================================================
  37.    Function Prototypes
  38.    ====================================================================== */
  39. void usage(char**);
  40. void init(void);
  41. double uniform(void);
  43. void dumpall(void);
  44. void ComputeW(void);
  45. void floyd_warshall(void);
  47. void show_diffs(void);
  48. void show_routes(void);
  49. void show_counters(void);
  52. /* ======================================================================
  53.    Global Variables
  54.    ====================================================================== */
  55. double         RANGE = 250.0; // transmitter range in meters
  56. double TIME = 0.0; // my clock;
  57. double MAXTIME = 0.0; // duration of simulation
  59. double MAXX = 0.0;
  60. double MAXY = 0.0;
  61. double MAXSPEED = 0.0;
  62. double PAUSE = 0.0;
  63. u_int32_t NODES = 0;
  64. u_int32_t RouteChangeCount = 0;
  65. u_int32_t       LinkChangeCount = 0;
  66. u_int32_t DestUnreachableCount = 0;
  68. Node *NodeList = 0;
  69. u_int32_t *D1 = 0;
  70. u_int32_t *D2 = 0;
  72. FILE            *in_file;
  73. FILE            *out_file;
  76. /* ======================================================================
  77.    Random Number Generation
  78.    ====================================================================== */
  79. #define M 2147483647L
  80. #define INVERSE_M ((double)4.656612875e-10)
  82. char random_state[32];
  83. RNG *rng;
  85. double
  86. uniform()
  87. {
  88. count++;
  89. return rng->uniform_double();
  90. }
  93. /* ======================================================================
  94.    Misc Functions...
  95.    ====================================================================== */
  96. void
  97. usage(char **argv)
  98. {
  99. fprintf(stderr,
  100. "nusage: %st[-n <nodes>] n",
  101. argv[0]);
  102. fprintf(stderr,
  103. "tt[-t <simulation time>]n");
  104. fprintf(stderr,
  105. "tt-i <input_file> -o <output file>n");
  106. fprintf(stderr,
  107. "tt #nodes, max time, and range read from scenario file if possiblenn");
  109. }
  111. void
  112. init()
  113. {
  114. /*
  115.  * Initialized the Random Number Generation
  116.  */
  118. /*
  119.  * Allocate memory for globals
  120.  */
  121. NodeList = new Node[NODES];
  122. if(NodeList == 0) {
  123. perror("new");
  124. exit(1);
  125. }
  127. D1 = new u_int32_t[NODES * NODES];
  128. if(D1 == 0) {
  129. perror("new");
  130. exit(1);
  131. }
  132. memset(D1, 'xff', sizeof(u_int32_t) * NODES * NODES);
  134. D2 = new u_int32_t[NODES * NODES];
  135. if(D2 == 0) {
  136. perror("new");
  137. exit(1);
  138. }
  139. memset(D2, 'xff', sizeof(u_int32_t) * NODES * NODES);
  140. }
  142. void
  143. OpenAndReadHeader(char *in_filename, char *out_filename)
  144.   /* assumes all initialization comments are at top of file with no
  145.      no lines that start with other than '#' */
  146. {
  147.   char buf[256];
  148.   
  149.   in_file = fopen(in_filename,"r");
  150.   out_file = fopen(out_filename,"w");
  151.   
  152.   if (NULL == in_file) 
  153. fprintf(stderr, "*** can't open inputfile %s",in_filename);
  154.   if (NULL == out_file) 
  155. fprintf(stderr,"can't open outputfile %s",out_filename);
  156.   
  157.   while (!feof(in_file)) {
  159.     *buf = fgetc(in_file);
  160.     ungetc(*buf,in_file);
  161.     if (*buf != '#') break;
  163.     fgets(buf, sizeof(buf), in_file);
  165.     /* check to see if we need data from the line */
  166.     sscanf(buf, "# nodes: %d, max time: %lf", &NODES, &MAXTIME);
  167.     sscanf(buf, "# nominal range: %lf", &RANGE);
  168.     
  169.     fprintf(out_file, "%s", buf);
  170.   }
  171.   NODES += 1; // correct for 1-based indexs
  172.   fflush(out_file);
  173. }
  175. void
  176. ReadInMovementPattern()
  177. {
  178.   char buf[256];
  179.   u_int n;
  180.   double x,y,z,t,s;
  181.   struct setdest *setdest;
  183.   while (!feof(in_file)) {
  185.     fgets(buf, sizeof(buf), in_file);
  186.     fprintf(out_file, "%s", buf);
  187.     if (*buf == '#') continue;
  188.     if (*buf == 'n') continue;
  190.     /* check to see if we need data from the line */
  191.     if (2 == sscanf(buf,"$node_(%d) set Z_ %lf", &n, &z)) 
  192.       {
  193. assert(n < NODES);
  194. NodeList[n].position.Z = z;
  195.       }
  196.     else if (2 == sscanf(buf,"$node_(%d) set X_ %lf", &n, &x)) 
  197.       {
  198. assert(n < NODES);
  199. NodeList[n].position.X = x;
  200.       }
  201.     else if (2 == sscanf(buf,"$node_(%d) set Y_ %lf", &n, &y)) 
  202.       {
  203. assert(n < NODES);
  204. NodeList[n].position.Y = y;
  205.       }
  206.     else if (5 == sscanf(buf,"$ns_ at %lf "$node_(%d) setdest %lf %lf %lf"", 
  207. &t, &n, &x, &y, &s)) 
  208.       {
  209. assert(n < NODES);
  210. assert(t <= MAXTIME);
  211. setdest = (struct setdest *)malloc(sizeof(*setdest));
  212. assert(setdest);
  213. setdest->X = x; setdest->Y = y; setdest->Z = 0;
  214. setdest->time = t;
  215. setdest->speed = s;
  216. if (NodeList[n].traj.lh_first 
  217.     && t > NodeList[n].traj.lh_first->time)
  218.   {
  219.     printf("setdest's must be in anti-chronological order in input file!n");
  220.     printf("failed on node %dn",n);
  221.     exit(-1);
  222.   }
  223. LIST_INSERT_HEAD(&NodeList[n].traj,setdest,traj);
  224.       }
  225.     else 
  226.       {
  227. printf("unparsable line: '%s'", buf);
  228. continue;
  229.       }
  230.   }  
  231.   fflush(out_file);  
  232. }
  234. extern "C" char *optarg;
  235. int
  236. main(int argc, char **argv)
  237. {
  238. char ch;
  239. char *in_filename = NULL;
  240. char *out_filename = NULL;
  242. while ((ch = getopt(argc, argv, "n:t:i:o:")) != EOF) {       
  244. switch (ch) { 
  246. case 'n':
  247. NODES = atoi(optarg) + 1;
  248. break;
  250. case 't':
  251. MAXTIME = atof(optarg);
  252. break;
  254. case 'i':
  255. in_filename = optarg;
  256. break;
  258. case 'o':
  259. out_filename = optarg;
  260. break;
  262. default:
  263. usage(argv);
  264. exit(1);
  265. }
  266. }
  268. if (NULL == in_filename || NULL == out_filename) {
  269.         usage(argv);
  270. exit(1);
  271. }
  273. OpenAndReadHeader(in_filename, out_filename);
  275. if(NODES == 0 || MAXTIME == 0.0) {
  276. usage(argv);
  277. exit(1);
  278. }
  279. // A more portable solution for random number generation
  280.         rng = new RNG;
  281.         rng->set_seed(RNG::HEURISTIC_SEED_SOURCE); 
  282. init();
  284. ReadInMovementPattern();
  286. while(TIME <= MAXTIME) {
  287. double nexttime = 0.0;
  288. u_int32_t i;
  290. for(i = 1; i < NODES; i++) {
  291. NodeList[i].Update();
  292. }
  294. for(i = 1; i < NODES; i++) {
  295. NodeList[i].UpdateNeighbors();
  296. }
  298. for(i = 1; i < NODES; i++) {
  299. Node *n = &NodeList[i];
  301. if(n->time_transition > 0.0) {
  302. if(nexttime == 0.0)
  303. nexttime = n->time_transition;
  304. else
  305. nexttime = min(nexttime, n->time_transition);
  306. }
  308. if(n->time_arrival > 0.0) {
  309. if(nexttime == 0.0)
  310. nexttime = n->time_arrival;
  311. else
  312. nexttime = min(nexttime, n->time_arrival);
  313. }
  314. }
  316. floyd_warshall();
  318. #ifdef DEBUG
  319. show_routes();
  320. #endif
  322.   show_diffs();
  324. #ifdef DEBUG
  325. dumpall();
  326. #endif
  328. if (nexttime <= TIME + ROUND_ERROR) 
  329.   TIME = MAXTIME + 1;   /* we're done */
  330. else 
  331.   TIME = nexttime;
  332. #ifdef OLD
  333. assert(nexttime > TIME + ROUND_ERROR);
  334. TIME = nexttime;
  335. #endif
  337. }
  339. show_counters();
  341. int of;
  342. if ((of = open(".rand_state",O_WRONLY | O_TRUNC | O_CREAT, 0777)) < 0)
  343.   fprintf(stderr,"open rand state");
  344. for (unsigned int i = 0; i < sizeof(random_state); i++)
  345.   random_state[i] = 0xff & (int) (uniform() * 256);
  346. if (write(of,random_state, sizeof(random_state)) < 0)
  347.   fprintf(stderr,"writing rand state");
  348. close(of);
  349. }
  352. /* ======================================================================
  353.    Node Class Functions
  354.    ====================================================================== */
  355. u_int32_t Node::NodeIndex = 0;
  357. Node::Node()
  358. {
  359. u_int32_t i;
  361. index = NodeIndex++;
  363. if(index == 0)
  364. return;
  366. route_changes = 0;
  367.         link_changes = 0;
  369.         /*
  370.          * For the first PAUSE seconds of the simulation, all nodes
  371.          * are stationary.
  372.          */
  373. time_arrival = TIME;
  374. time_update = TIME;
  375. time_transition = 0.0;
  377. position.X = position.Y = position.Z = 0.0;
  378. destination.X = destination.Y = destination.Z = 0.0;
  379. direction.X = direction.Y = direction.Z = 0.0;
  380. speed = 0.0;
  382. neighbor = new Neighbor[NODES];
  383. if(neighbor == 0) {
  384. perror("new");
  385. exit(1);
  386. }
  388. LIST_INIT(&traj);
  390. for(i = 1; i < NODES; i++) {
  391. neighbor[i].index = i;
  392. neighbor[i].reachable = (index == i) ? 1 : 0;
  393. neighbor[i].time_transition = 0.0;
  394. }
  395. }
  399. void
  400. Node::RandomPosition()
  401. {
  402. position.X = uniform() * MAXX;
  403. position.Y = uniform() * MAXY;
  404. position.Z = 0.0;
  405. }
  408. void
  409. Node::RandomDestination()
  410. {
  411. destination.X = uniform() * MAXX;
  412. destination.Y = uniform() * MAXY;
  413. destination.Z = 0.0;
  414. assert(destination != position);
  415. }
  417. void
  418. Node::RandomSpeed()
  419. {
  420. speed = uniform() * MAXSPEED;
  422. assert(speed != 0.0);
  423. }
  426. void
  427. Node::Update()
  428. {
  429.         struct setdest *setdest = traj.lh_first;
  431. position += (speed * (TIME - time_update)) * direction;
  433. if(TIME == time_arrival) {
  435.   if (NULL == setdest) 
  436.     {
  437.       destination = position;
  438.       direction.X = direction.Y = direction.Z = 0.0;
  439.       speed = 0.0;
  440.       time_arrival = MAXTIME + 1;
  441.     } 
  442.   else 
  443.     {
  444.       vector v;
  445.       destination.X = setdest->X;
  446.       destination.Y = setdest->Y;
  447.       speed = setdest->speed;
  448.       if (0.0 == speed)
  449. { // it's a pause at the current location
  450.   if (LIST_NEXT(setdest,traj))
  451.     time_arrival = LIST_NEXT(setdest,traj)->time;
  452.   else
  453.     time_arrival = MAXTIME + 1;
  454. }
  455.       else 
  456. { // we're moving somewhere, when do we get there?
  457.   v = destination - position;
  458.   direction = v / v.length();
  459.   time_arrival = TIME + v.length() / speed;
  460. }
  461.       LIST_REMOVE(setdest,traj);
  462.       free(setdest);
  463.     }
  464. }
  466. time_update = TIME;
  467. time_transition = 0.0;
  468. }
  471. void
  472. Node::UpdateNeighbors()
  473. {
  474. static Node *n2;
  475. static Neighbor *m1, *m2;
  476. static vector D, B, v1, v2;
  477. static double a, b, c, t1, t2, Q;
  478. static u_int32_t i, reachable;
  480. v1 = speed * direction;
  482. /*
  483.  *  Only need to go from INDEX --> N for each one since links
  484.  *  are symmetric.
  485.  */
  486. for(i = index+1; i < NODES; i++) {
  488. m1 = &neighbor[i];
  489. n2 = &NodeList[i];
  490. m2 = &n2->neighbor[index];
  492. assert(i == m1->index);
  493. assert(m1->index == n2->index);
  494. assert(index == m2->index);
  495.                 assert(m1->reachable == m2->reachable);
  497.                 reachable = m1->reachable;
  499. /* ==================================================
  500.    Determine Reachability
  501.    ================================================== */
  502. { vector d = position - n2->position;
  504. if(d.length() < RANGE) {
  505. #ifdef SANITY_CHECKS
  506. if(TIME > 0.0 && m1->reachable == 0)
  507. assert(RANGE - d.length() < ROUND_ERROR);
  508. #endif
  509. m1->reachable = m2->reachable = 1;
  510. }
  511. // Boundary condition handled below.
  512. else {
  513. #ifdef SANITY_CHECKS
  514. if(TIME > 0.0 && m1->reachable == 1)
  515. assert(d.length() - RANGE < ROUND_ERROR);
  516. #endif
  517. m1->reachable = m2->reachable = 0;
  518. }
  519. #ifdef DEBUG
  520.                         fprintf(stdout, "# %.6f (%d, %d) %.2fmn",
  521.                                 TIME, index, m1->index, d.length());
  522. #endif
  523. }
  525. /* ==================================================
  526.    Determine Next Event Time
  527.    ================================================== */
  528. v2 = n2->speed * n2->direction;
  530. D = v2 - v1;
  531. B = n2->position - position;
  533. a = (D.X * D.X) + (D.Y * D.Y) + (D.Z * D.Z);
  534. b = 2 * ((D.X * B.X) + (D.Y * B.Y) + (D.Z * B.Z));
  535. c = (B.X * B.X) + (B.Y * B.Y) + (B.Z * B.Z) - (RANGE * RANGE);
  537. if(a == 0.0) {
  538. /*
  539.  *  No Finite Solution
  540.  */
  541. m1->time_transition= 0.0;
  542. m2->time_transition= 0.0;
  543. goto  next;
  544. }
  546. Q = b * b - 4 * a * c;
  547. if(Q < 0.0) {
  548. /*
  549.  *  No real roots.
  550.  */
  551. m1->time_transition = 0.0;
  552. m2->time_transition = 0.0;
  553. goto next;
  554. }
  555. Q = sqrt(Q);
  557. t1 = (-b + Q) / (2 * a);
  558. t2 = (-b - Q) / (2 * a);
  560. // Stupid Rounding/Boundary Cases
  561. if(t1 > 0.0 && t1 < ROUND_ERROR) t1 = 0.0;
  562. if(t1 < 0.0 && -t1 < ROUND_ERROR) t1 = 0.0;
  563. if(t2 > 0.0 && t2 < ROUND_ERROR) t2 = 0.0;
  564. if(t2 < 0.0 && -t2 < ROUND_ERROR) t2 = 0.0;
  566. if(t1 < 0.0 && t2 < 0.0) {
  567. /*
  568.  *  No "future" time solution.
  569.  */
  570. m1->time_transition = 0.0;
  571. m2->time_transition = 0.0;
  572. goto next;
  573. }
  575. /*
  576.  * Boundary conditions.
  577.  */
  578. if((t1 == 0.0 && t2 > 0.0) || (t2 == 0.0 && t1 > 0.0)) {
  579. m1->reachable = m2->reachable = 1;
  580. m1->time_transition = m2->time_transition = TIME + max(t1, t2);
  581. }
  582. else if((t1 == 0.0 && t2 < 0.0) || (t2 == 0.0 && t1 < 0.0)) {
  583. m1->reachable = m2->reachable = 0;
  584. m1->time_transition = m2->time_transition = 0.0;
  585. }
  587. /*
  588.  * Non-boundary conditions.
  589.  */
  590. else if(t1 > 0.0 && t2 > 0.0) {
  591. m1->time_transition = TIME + min(t1, t2);
  592. m2->time_transition = TIME + min(t1, t2);
  593. }
  594. else if(t1 > 0.0) {
  595. m1->time_transition = TIME + t1;
  596. m2->time_transition = TIME + t1;
  597. }
  598. else {
  599. m1->time_transition = TIME + t2;
  600. m2->time_transition = TIME + t2;
  601. }
  603. /* ==================================================
  604.    Update the transition times for both NODEs.
  605.    ================================================== */
  606. if(time_transition == 0.0 || (m1->time_transition &&
  607.    time_transition > m1->time_transition)) {
  608. time_transition = m1->time_transition;
  609. }
  610. if(n2->time_transition == 0.0 || (m2->time_transition &&
  611.    n2->time_transition > m2->time_transition)) {
  612. n2->time_transition = m2->time_transition;
  613. }
  614.         next:
  615.                 if(reachable != m1->reachable && TIME > 0.0) {
  616.                         LinkChangeCount++;
  617.                         link_changes++;
  618.                         n2->link_changes++;
  619.                 }
  620. }
  621. }
  623. void
  624. Node::Dump()
  625. {
  626. Neighbor *m;
  627. u_int32_t i;
  629. fprintf(stdout,
  630. "Node: %dtpos: (%.2f, %.2f, %.2f) dst: (%.2f, %.2f, %.2f)n",
  631. index, position.X, position.Y, position.Z,
  632. destination.X, destination.Y, destination.Z);
  633. fprintf(stdout, "tdir: (%.2f, %.2f, %.2f) speed: %.2fn",
  634. direction.X, direction.Y, direction.Z, speed);
  635. fprintf(stdout, "tArrival: %.2f, Update: %.2f, Transition: %.2fn",
  636. time_arrival, time_update, time_transition);
  638. for(i = 1; i < NODES; i++) {
  639. m = &neighbor[i];
  640. fprintf(stdout, "tNeighbor: %d (%lx), Reachable: %d, Transition Time: %.2fn",
  641. m->index, (long) m, m->reachable, m->time_transition);
  642. }
  643. }
  646. /* ======================================================================
  647.    Dijkstra's Shortest Path Algoritm
  648.    ====================================================================== */
  649. void dumpall()
  650. {
  651. u_int32_t i;
  653. fprintf(stdout, "nTime: %.2fn", TIME);
  655. for(i = 1; i < NODES; i++) {
  656. NodeList[i].Dump();
  657. }
  658. }
  660. void
  661. ComputeW()
  662. {
  663. u_int32_t i, j;
  664. u_int32_t *W = D2;
  666. memset(W, 'xff', sizeof(int) * NODES * NODES);
  668. for(i = 1; i < NODES; i++) {
  669. for(j = i; j < NODES; j++) {
  670. Neighbor *m = &NodeList[i].neighbor[j];
  671. if(i == j)
  672. W[i*NODES + j] = W[j*NODES + i] = 0;
  673. else
  674. W[i*NODES + j] = W[j*NODES + i] = m->reachable ? 1 : INFINITY;
  675. }
  676. }
  677. }
  679. void
  680. floyd_warshall()
  681. {
  682. u_int32_t i, j, k;
  684. ComputeW(); // the connectivity matrix
  686. for(i = 1; i < NODES; i++) {
  687. for(j = 1; j < NODES; j++) {
  688. for(k = 1; k < NODES; k++) {
  689. D2[j*NODES + k] = min(D2[j*NODES + k], D2[j*NODES + i] + D2[i*NODES + k]);
  690. }
  691. }
  692. }
  694. #ifdef SANITY_CHECKS
  695. for(i = 1; i < NODES; i++)
  696. for(j = 1; j < NODES; j++) {
  697. assert(D2[i*NODES + j] == D2[j*NODES + i]);
  698. assert(D2[i*NODES + j] <= INFINITY);
  699. }
  700. #endif
  701. }
  704. /*
  705.  *  Write the actual GOD entries to a TCL script.
  706.  */
  707. void
  708. show_diffs()
  709. {
  710. u_int32_t i, j;
  712. for(i = 1; i < NODES; i++) {
  713. for(j = i + 1; j < NODES; j++) {
  714. if(D1[i*NODES + j] != D2[i*NODES + j]) {
  716. if(D2[i*NODES + j] == INFINITY)
  717. DestUnreachableCount++;
  719.                                 if(TIME > 0.0) {
  720.                                         RouteChangeCount++;
  721.                                         NodeList[i].route_changes++;
  722.                                         NodeList[j].route_changes++;
  723.                                 }
  725. if(TIME == 0.0) {
  726. fprintf(out_file, GOD_FORMAT2,
  727. i, j, D2[i*NODES + j]);
  728. #ifdef SHOW_SYMMETRIC_PAIRS
  729. fprintf(out_file, GOD_FORMAT2,
  730. j, i, D2[j*NODES + i]);
  731. #endif
  732. }
  733. else {
  734. fprintf(out_file, GOD_FORMAT, 
  735. TIME, i, j, D2[i*NODES + j]);
  736. #ifdef SHOW_SYMMETRIC_PAIRS
  737. fprintf(out_file, GOD_FORMAT, 
  738. TIME, j, i, D2[j*NODES + i]);
  739. #endif
  740. }
  741. }
  742. }
  743. }
  745. memcpy(D1, D2, sizeof(int) * NODES * NODES);
  746. }
  749. void
  750. show_routes()
  751. {
  752. u_int32_t i, j;
  754. fprintf(stdout, "#n# TIME: %.12fn#n", TIME);
  755. for(i = 1; i < NODES; i++) {
  756. fprintf(stdout, "# %2d) ", i);
  757. for(j = 1; j < NODES; j++)
  758. fprintf(stdout, "%3d ", D2[i*NODES + j] & 0xff);
  759. fprintf(stdout, "n");
  760. }
  761. fprintf(stdout, "#n");
  762. }
  764. void
  765. show_counters()
  766. {
  767. u_int32_t i;
  769. fprintf(out_file, "#n# Destination Unreachables: %dn#n",
  770. DestUnreachableCount);
  771. fprintf(out_file, "# Route Changes: %dn#n", RouteChangeCount);
  772.         fprintf(out_file, "# Link Changes: %dn#n", LinkChangeCount);
  773.         fprintf(out_file, "# Node | Route Changes | Link Changesn");
  774. for(i = 1; i < NODES; i++)
  775. fprintf(out_file, "# %4d |          %4d |         %4dn",
  776.                         i, NodeList[i].route_changes,
  777.                         NodeList[i].link_changes);
  778. fprintf(out_file, "#n");
  779. }