Dave Jarvis' Repositories

order.txt

<?php

require_once 'GitDiff.php';

class DiffPage extends BasePage {

  private $currentRepo;

  private $git;

  private $hash;

  public function __construct(array $repositories, array $currentRepo, Git $git, string $hash) {

    parent::__construct($repositories);

    $this->currentRepo = $currentRepo;

    $this->git = $git;

    $this->hash = $hash;

    $this->title = substr($hash, 0, 7);

  }

  public function render() {

    $this->renderLayout(function() {

      $commitData = $this->git->read($this->hash);

      $diffEngine = new GitDiff($this->git);

      $lines = explode("\n", $commitData);

      $msg = '';

      $isMsg = false;

      $headers = [];

      foreach ($lines as $line) {

        if ($line === '') { $isMsg = true; continue; }

        if ($isMsg) { $msg .= $line . "\n"; }

        else {

            if (preg_match('/^(\w+) (.*)$/', $line, $m)) $headers[$m[1]] = $m[2];

        }

      }

      $changes = $diffEngine->compare($this->hash);

      $this->renderBreadcrumbs();

      echo '<div class="commit-details">';

      echo '<div class="commit-header">';

      echo '<h1 class="commit-title">' . htmlspecialchars(trim($msg)) . '</h1>';

      echo '<div class="commit-info">';

      echo '<div class="commit-info-row"><span class="commit-info-label">Author</span><span class="commit-author">' . htmlspecialchars($headers['author'] ?? 'Unknown') . '</span></div>';

      echo '<div class="commit-info-row"><span class="commit-info-label">Commit</span><span class="commit-info-value">' . $this->hash . '</span></div>';

      if (isset($headers['parent'])) {

          $repoUrl = '?repo=' . urlencode($this->currentRepo['safe_name']);

          echo '<div class="commit-info-row"><span class="commit-info-label">Parent</span><span class="commit-info-value">';

          echo '<a href="?action=commit&hash=' . $headers['parent'] . $repoUrl . '" class="parent-link">' . substr($headers['parent'], 0, 7) . '</a>';

          echo '</span></div>';

      }

      echo '</div></div></div>';

      echo '<div class="diff-container">';

      foreach ($changes as $change) {

        $this->renderFileDiff($change);

      }

      if (empty($changes)) {

          echo '<div class="empty-state"><p>No changes detected.</p></div>';

      }

      echo '</div>';

    }, $this->currentRepo);

  }

  private function renderFileDiff($change) {

    $statusIcon = 'fa-file';

    $statusClass = '';

    if ($change['type'] === 'A') { $statusIcon = 'fa-plus-circle'; $statusClass = 'status-add'; }

    if ($change['type'] === 'D') { $statusIcon = 'fa-minus-circle'; $statusClass = 'status-del'; }

    if ($change['type'] === 'M') { $statusIcon = 'fa-pencil-alt'; $statusClass = 'status-mod'; }

    echo '<div class="diff-file">';

    echo '<div class="diff-header">';

    echo '<span class="diff-status ' . $statusClass . '"><i class="fa ' . $statusIcon . '"></i></span>';

    echo '<span class="diff-path">' . htmlspecialchars($change['path']) . '</span>';

    echo '</div>';

    if ($change['is_binary']) {

        echo '<div class="diff-binary">Binary files differ</div>';

    } else {

        echo '<div class="diff-content">';

        echo '<table><tbody>';

        foreach ($change['hunks'] as $line) {

            if (isset($line['t']) && $line['t'] === 'gap') {

                echo '<tr class="diff-gap"><td colspan="3">...</td></tr>';

                continue;

            }

            $class = 'diff-ctx';

            $char = ' ';

            if ($line['t'] === '+') { $class = 'diff-add'; $char = '+'; }

            if ($line['t'] === '-') { $class = 'diff-del'; $char = '-'; }

            echo '<tr class="' . $class . '">';

            echo '<td class="diff-num" data-num="' . $line['no'] . '"></td>';

            echo '<td class="diff-num" data-num="' . $line['nn'] . '"></td>';

            echo '<td class="diff-code"><span class="diff-marker">' . $char . '</span>' . htmlspecialchars($line['l']) . '</td>';

            echo '</tr>';

        }

        echo '</tbody></table>';

        echo '</div>';

    }

    echo '</div>';

  }

  private function renderBreadcrumbs() {

    $repoUrl = '?repo=' . urlencode( $this->currentRepo['safe_name'] );

    $crumbs = [

      '<a href="?">Repositories</a>',

      '<a href="' . $repoUrl . '">' . htmlspecialchars($this->currentRepo['name']) . '</a>',

      '<a href="?action=commits' . $repoUrl . '">Commits</a>',

      substr($this->hash, 0, 7)

    ];

    echo '<div class="breadcrumb">' . implode(' / ', $crumbs) . '</div>';

  }

}

require_once 'GitRefs.php';

require_once 'GitPacks.php';

class Git {

  private const CHUNK_SIZE = 128;

  private string $repoPath;

  private string $objectsPath;

  private GitRefs $refs;

  private GitPacks $packs;

  public function __construct( string $repoPath ) {

    $this->setRepository( $repoPath );

  }

  public function setRepository( string $repoPath ): void {

    $this->repoPath    = rtrim( $repoPath, '/' );

    $this->objectsPath = $this->repoPath . '/objects';

    $this->refs  = new GitRefs( $this->repoPath );

    $this->packs = new GitPacks( $this->objectsPath );

  }

  public function resolve( string $reference ): string {

    return $this->refs->resolve( $reference );

  }

  public function getMainBranch(): array {

    return $this->refs->getMainBranch();

  }

  public function eachBranch( callable $callback ): void {

    $this->refs->scanRefs( 'refs/heads', $callback );

  }

  public function eachTag( callable $callback ): void {

    $this->refs->scanRefs( 'refs/tags', $callback );

  }

  public function getObjectSize( string $sha ): int {

    $size = $this->packs->getSize( $sha );

    if( $size !== null ) {

      return $size;

    }

    return $this->getLooseObjectSize( $sha );

  }

  public function read( string $sha ): string {

    $loosePath = $this->getLoosePath( $sha );

    if( file_exists( $loosePath ) ) {

      $rawContent = file_get_contents( $loosePath );

      $inflated   = $rawContent ? @gzuncompress( $rawContent ) : false;

      return $inflated ? explode( "\0", $inflated, 2 )[1] : '';

    }

    return $this->packs->read( $sha ) ?? '';

  }

  public function stream( string $sha, callable $callback ): void {

    $data = $this->read( $sha );

    if( $data !== '' ) {

      $callback( $data );

    }

  }

  public function history( string $ref, int $limit, callable $callback ): void {

    $currentSha = $this->resolve( $ref );

    $count      = 0;

    while( $currentSha !== '' && $count < $limit ) {

      $data = $this->read( $currentSha );

      if( $data === '' ) {

        break;

      }

      $position = strpos( $data, "\n\n" );

      $message  = $position !== false ? substr( $data, $position + 2 ) : '';

      preg_match( '/^author (.*) <(.*)> (\d+)/m', $data, $matches );

      $callback( (object)[

        'sha'     => $currentSha,

        'message' => trim( $message ),

        'author'  => $matches[1] ?? 'Unknown',

        'email'   => $matches[2] ?? '',

        'date'    => (int)( $matches[3] ?? 0 )

      ] );

      $currentSha = preg_match(

        '/^parent ([0-9a-f]{40})$/m',

        $data,

        $parentMatches

      ) ? $parentMatches[1] : '';

      $count++;

    }

  }

  public function walk( string $refOrSha, callable $callback ): void {

    $sha  = $this->resolve( $refOrSha );

    $data = $sha !== '' ? $this->read( $sha ) : '';

    if( preg_match( '/^tree ([0-9a-f]{40})$/m', $data, $matches ) ) {

      $data = $this->read( $matches[1] );

    }

    if( $this->isTreeData( $data ) ) {

      $this->processTree( $data, $callback );

    }

  }

  private function processTree( string $data, callable $callback ): void {

    $position = 0;

    $length   = strlen( $data );

    while( $position < $length ) {

      $spacePos = strpos( $data, ' ', $position );

      $nullPos  = strpos( $data, "\0", $spacePos );

      if( $spacePos === false || $nullPos === false ) {

        break;

      }

      $mode = substr( $data, $position, $spacePos - $position );

      $name = substr( $data, $spacePos + 1, $nullPos - $spacePos - 1 );

      $sha  = bin2hex( substr( $data, $nullPos + 1, 20 ) );

      $isDirectory = $mode === '40000' || $mode === '040000';

      $size        = $isDirectory ? 0 : $this->getObjectSize( $sha );

      $callback( new File( $name, $sha, $mode, 0, $size ) );

      $position = $nullPos + 21;

    }

  }

  private function isTreeData( string $data ): bool {

    $pattern = '/^(40000|100644|100755|120000|160000) /';

    if( strlen( $data ) >= 25 && preg_match( $pattern, $data ) ) {

      $nullPos = strpos( $data, "\0" );

      return $nullPos !== false && ($nullPos + 21 <= strlen( $data ));

    }

    return false;

  }

  private function getLoosePath( string $sha ): string {

    return "{$this->objectsPath}/" . substr( $sha, 0, 2 ) . "/" .

           substr( $sha, 2 );

  }

  private function getLooseObjectSize( string $sha ): int {

    $path = $this->getLoosePath( $sha );

    if( !file_exists( $path ) ) {

      return 0;

    }

    $fileHandle = @fopen( $path, 'rb' );

    if( !$fileHandle ) {

      return 0;

    }

    $data     = '';

    $inflator = inflate_init( ZLIB_ENCODING_DEFLATE );

    while( !feof( $fileHandle ) ) {

      $chunk  = fread( $fileHandle, self::CHUNK_SIZE );

      $output = @inflate_add( $inflator, $chunk, ZLIB_NO_FLUSH );

      if( $output === false ) {

        break;

      }

      $data .= $output;

      if( strpos( $data, "\0" ) !== false ) {

        break;

      }

    }

    fclose( $fileHandle );

    $header = explode( "\0", $data, 2 )[0];

    $parts  = explode( ' ', $header );

    return isset( $parts[1] ) ? (int)$parts[1] : 0;

<?php

require_once 'File.php';

class GitDiff {

  private $git;

  public function __construct(Git $git) {

    $this->git = $git;

  }

  public function compare(string $commitHash) {

    $commitData = $this->git->read($commitHash);

    $parentHash = '';

    if (preg_match('/^parent ([0-9a-f]{40})/m', $commitData, $matches)) {

      $parentHash = $matches[1];

    }

    $newTree = $this->getTreeHash($commitHash);

    $oldTree = $parentHash ? $this->getTreeHash($parentHash) : null;

    return $this->diffTrees($oldTree, $newTree);

  }

  private function getTreeHash($commitSha) {

    $data = $this->git->read($commitSha);

    if (preg_match('/^tree ([0-9a-f]{40})/m', $data, $matches)) {

      return $matches[1];

    }

    return null;

  }

  private function diffTrees($oldTreeSha, $newTreeSha, $path = '') {

    $changes = [];

    if ($oldTreeSha === $newTreeSha) return [];

    $oldEntries = $oldTreeSha ? $this->parseTree($oldTreeSha) : [];

    $newEntries = $newTreeSha ? $this->parseTree($newTreeSha) : [];

    $allNames = array_unique(array_merge(array_keys($oldEntries), array_keys($newEntries)));

    sort($allNames);

    foreach ($allNames as $name) {

      $old = $oldEntries[$name] ?? null;

      $new = $newEntries[$name] ?? null;

      $currentPath = $path ? "$path/$name" : $name;

      if (!$old) {

        if ($new['is_dir']) {

           $changes = array_merge($changes, $this->diffTrees(null, $new['sha'], $currentPath));

        } else {

           $changes[] = $this->createChange('A', $currentPath, null, $new['sha']);

        }

      } elseif (!$new) {

        if ($old['is_dir']) {

           $changes = array_merge($changes, $this->diffTrees($old['sha'], null, $currentPath));

        } else {

           $changes[] = $this->createChange('D', $currentPath, $old['sha'], null);

        }

      } elseif ($old['sha'] !== $new['sha']) {

        if ($old['is_dir'] && $new['is_dir']) {

          $changes = array_merge($changes, $this->diffTrees($old['sha'], $new['sha'], $currentPath));

        } elseif (!$old['is_dir'] && !$new['is_dir']) {

          $changes[] = $this->createChange('M', $currentPath, $old['sha'], $new['sha']);

        }

      }

    }

    return $changes;

  }

  private function parseTree($sha) {

    $data = $this->git->read($sha);

    $entries = [];

    $len = strlen($data);

    $pos = 0;

    while ($pos < $len) {

      $space = strpos($data, ' ', $pos);

      $null = strpos($data, "\0", $space);

      if ($space === false || $null === false) break;

      $mode = substr($data, $pos, $space - $pos);

      $name = substr($data, $space + 1, $null - $space - 1);

      $hash = bin2hex(substr($data, $null + 1, 20));

      $entries[$name] = [

        'mode' => $mode,

        'sha' => $hash,

        'is_dir' => ($mode === '40000' || $mode === '040000')

      ];

      $pos = $null + 21;

    }

    return $entries;

  }

  private function createChange($type, $path, $oldSha, $newSha) {

    $oldContent = $oldSha ? $this->git->read($oldSha) : '';

    $newContent = $newSha ? $this->git->read($newSha) : '';

    $isBinary = false;

    if ($newSha) {

        $f = new VirtualDiffFile($path, $newContent);

        if ($f->isBinary()) $isBinary = true;

    }

    if (!$isBinary && $oldSha) {

        $f = new VirtualDiffFile($path, $oldContent);

        if ($f->isBinary()) $isBinary = true;

    }

    $diff = null;

    if (!$isBinary) {

      $diff = $this->calculateDiff($oldContent, $newContent);

    }

    return [

      'type' => $type,

      'path' => $path,

      'is_binary' => $isBinary,

      'hunks' => $diff

    ];

  }

  private function calculateDiff($old, $new) {

    // Normalize line endings

    $old = str_replace("\r\n", "\n", $old);

    $new = str_replace("\r\n", "\n", $new);

    $oldLines = explode("\n", $old);

    $newLines = explode("\n", $new);

    $m = count($oldLines);

    $n = count($newLines);

    // LCS Algorithm

    $start = 0;

    while ($start < $m && $start < $n && $oldLines[$start] === $newLines[$start]) {

      $start++;

    }

    $end = 0;

    while ($m - $end > $start && $n - $end > $start && $oldLines[$m - 1 - $end] === $newLines[$n - 1 - $end]) {

      $end++;

    }

    $oldSlice = array_slice($oldLines, $start, $m - $start - $end);

    $newSlice = array_slice($newLines, $start, $n - $start - $end);

    $ops = $this->computeLCS($oldSlice, $newSlice);

    // Grouping Optimization: Reorder interleaved +/- to be - then +

    $groupedOps = [];

    $bufferDel = [];

    $bufferAdd = [];

    foreach ($ops as $op) {

        if ($op['t'] === ' ') {

            foreach ($bufferDel as $o) $groupedOps[] = $o;

            foreach ($bufferAdd as $o) $groupedOps[] = $o;

            $bufferDel = [];

            $bufferAdd = [];

            $groupedOps[] = $op;

        } elseif ($op['t'] === '-') {

            $bufferDel[] = $op;

        } elseif ($op['t'] === '+') {

            $bufferAdd[] = $op;

        }

    }

    foreach ($bufferDel as $o) $groupedOps[] = $o;

    foreach ($bufferAdd as $o) $groupedOps[] = $o;

    $ops = $groupedOps;

    // Generate Stream with Context

    $stream = [];

    // Prefix context

    for ($i = 0; $i < $start; $i++) {

        $stream[] = ['t' => ' ', 'l' => $oldLines[$i], 'no' => $i + 1, 'nn' => $i + 1];

    }

    $currO = $start + 1;

    $currN = $start + 1;

    foreach ($ops as $op) {

        if ($op['t'] === ' ') {

            $stream[] = ['t' => ' ', 'l' => $op['l'], 'no' => $currO++, 'nn' => $currN++];

        } elseif ($op['t'] === '-') {

            $stream[] = ['t' => '-', 'l' => $op['l'], 'no' => $currO++, 'nn' => null];

        } elseif ($op['t'] === '+') {

            $stream[] = ['t' => '+', 'l' => $op['l'], 'no' => null, 'nn' => $currN++];

        }

    }

    // Suffix context

    for ($i = $m - $end; $i < $m; $i++) {

        $stream[] = ['t' => ' ', 'l' => $oldLines[$i], 'no' => $currO++, 'nn' => $currN++];

    }

    // Filter to Hunks

    $finalLines = [];

    $lastVisibleIndex = -1;

    $streamLen = count($stream);

    $contextLines = 3;

    for ($i = 0; $i < $streamLen; $i++) {

        $show = false;

        if ($stream[$i]['t'] !== ' ') {

            $show = true;

        } else {

            // Check ahead

            for ($j = 1; $j <= $contextLines; $j++) {

                if (($i + $j) < $streamLen && $stream[$i + $j]['t'] !== ' ') {

                    $show = true;

                    break;

                }

            }

            // Check behind

            if (!$show) {

                for ($j = 1; $j <= $contextLines; $j++) {

                    if (($i - $j) >= 0 && $stream[$i - $j]['t'] !== ' ') {

                        $show = true;

                        break;

                    }

                }

            }

        }

        if ($show) {

            if ($lastVisibleIndex !== -1 && $i > $lastVisibleIndex + 1) {

                $finalLines[] = ['t' => 'gap'];

            }

            $finalLines[] = $stream[$i];

            $lastVisibleIndex = $i;

        }

    }

    return $finalLines;

  }

  private function computeLCS($old, $new) {

    $m = count($old);

    $n = count($new);

    $c = array_fill(0, $m + 1, array_fill(0, $n + 1, 0));

    for ($i = 1; $i <= $m; $i++) {

      for ($j = 1; $j <= $n; $j++) {

        if ($old[$i-1] === $new[$j-1]) {

          $c[$i][$j] = $c[$i-1][$j-1] + 1;

        } else {

          $c[$i][$j] = max($c[$i][$j-1], $c[$i-1][$j]);

        }

      }

    }

    $diff = [];

    $i = $m; $j = $n;

    while ($i > 0 || $j > 0) {

      if ($i > 0 && $j > 0 && $old[$i-1] === $new[$j-1]) {

        array_unshift($diff, ['t' => ' ', 'l' => $old[$i-1]]);

        $i--; $j--;

      } elseif ($j > 0 && ($i === 0 || $c[$i][$j-1] >= $c[$i-1][$j])) {

        array_unshift($diff, ['t' => '+', 'l' => $new[$j-1]]);

        $j--;

      } elseif ($i > 0 && ($j === 0 || $c[$i][$j-1] < $c[$i-1][$j])) {

        array_unshift($diff, ['t' => '-', 'l' => $old[$i-1]]);

        $i--;

      }

    }

    return $diff;

  }

}

class VirtualDiffFile extends File {

  private $content;

  private $vName;

  public function __construct($name, $content) {

    parent::__construct($name, '', '100644', 0, strlen($content));

    $this->vName = $name;

    $this->content = $content;

  }

  public function isBinary(): bool {

    $buffer = substr($this->content, 0, 12);

    return MediaTypeSniffer::isBinary($buffer, $this->vName);

  }

}

<?php

class GitPacks {

  private const MAX_READ = 16777216;

  private string $objectsPath;

  private array $packFiles;

  private ?string $lastPack = null;

  private array $fileHandles       = [];

  private array $fanoutCache       = [];

  private array $shaBucketCache    = [];

  private array $offsetBucketCache = [];

  public function __construct( string $objectsPath ) {

    $this->objectsPath = $objectsPath;

    $this->packFiles   = glob( "{$this->objectsPath}/pack/*.idx" ) ?: [];

  }

  public function __destruct() {

    foreach( $this->fileHandles as $handle ) {

      if( is_resource( $handle ) ) {

        fclose( $handle );

      }

    }

  }

  public function read( string $sha ): ?string {

    $info = $this->findPackInfo( $sha );

    if( $info['offset'] === -1 ) {

      return null;

    }

    $handle = $this->getHandle( $info['file'] );

    return $handle

      ? $this->readPackEntry( $handle, $info['offset'] )

      : null;

  }

  public function getSize( string $sha ): ?int {

    $info = $this->findPackInfo( $sha );

    if( $info['offset'] === -1 ) {

      return null;

    }

    return $this->extractPackedSize( $info['file'], $info['offset'] );

  }

  private function findPackInfo( string $sha ): array {

    if( !ctype_xdigit( $sha ) || strlen( $sha ) !== 40 ) {

      return ['offset' => -1];

    }

    $binarySha = hex2bin( $sha );

    if( $this->lastPack ) {

      $offset = $this->findInIdx( $this->lastPack, $binarySha );

      if( $offset !== -1 ) {

        return $this->makeResult( $this->lastPack, $offset );

      }

    }

    foreach( $this->packFiles as $indexFile ) {

      if( $indexFile === $this->lastPack ) {

        continue;

      }

      $offset = $this->findInIdx( $indexFile, $binarySha );

      if( $offset !== -1 ) {

        $this->lastPack = $indexFile;

        return $this->makeResult( $indexFile, $offset );

      }

    }

    return ['offset' => -1];

  }

  private function makeResult( string $indexPath, int $offset ): array {

    return [

      'file'   => str_replace( '.idx', '.pack', $indexPath ),

      'offset' => $offset

    ];

  }

  private function findInIdx( string $indexFile, string $binarySha ): int {

    $fileHandle = $this->getHandle( $indexFile );

    if( !$fileHandle ) {

      return -1;

    }

    if( !isset( $this->fanoutCache[$indexFile] ) ) {

      fseek( $fileHandle, 0 );

      if( fread( $fileHandle, 8 ) === "\377tOc\0\0\0\2" ) {

        $this->fanoutCache[$indexFile] = array_values(

          unpack( 'N*', fread( $fileHandle, 1024 ) )

        );

      } else {

        return -1;

      }

    }

    $fanout = $this->fanoutCache[$indexFile];

    $firstByte = ord( $binarySha[0] );

    $start     = $firstByte === 0 ? 0 : $fanout[$firstByte - 1];

    $end       = $fanout[$firstByte];

    if( $end <= $start ) {

      return -1;

    }

    $cacheKey = "$indexFile:$firstByte";

    if( !isset( $this->shaBucketCache[$cacheKey] ) ) {

      $count = $end - $start;

      fseek( $fileHandle, 1032 + ($start * 20) );

      $this->shaBucketCache[$cacheKey] = fread( $fileHandle, $count * 20 );

      fseek(

        $fileHandle,

        1032 + ($fanout[255] * 24) + ($start * 4)

      );

      $this->offsetBucketCache[$cacheKey] = fread( $fileHandle, $count * 4 );

    }

    $shaBlock  = $this->shaBucketCache[$cacheKey];

    $count     = strlen( $shaBlock ) / 20;

    $low       = 0;

    $high      = $count - 1;

    $foundIdx  = -1;

    while( $low <= $high ) {

      $mid     = ($low + $high) >> 1;

      $compare = substr( $shaBlock, $mid * 20, 20 );

      if( $compare < $binarySha ) {

        $low = $mid + 1;

      } elseif( $compare > $binarySha ) {

        $high = $mid - 1;

      } else {

        $foundIdx = $mid;

        break;

      }

    }

    if( $foundIdx === -1 ) {

      return -1;

    }

    $offsetData = substr(

      $this->offsetBucketCache[$cacheKey],

      $foundIdx * 4,

      4

    );

    $offset = unpack( 'N', $offsetData )[1];

    if( $offset & 0x80000000 ) {

      $packTotal = $fanout[255];

      $pos64     = 1032 + ($packTotal * 28) +

                   (($offset & 0x7FFFFFFF) * 8);

      fseek( $fileHandle, $pos64 );

      $offset = unpack( 'J', fread( $fileHandle, 8 ) )[1];

    }

    return (int)$offset;

  }

  // $fileHandle is resource, no type hint used for compatibility

  private function readPackEntry( $fileHandle, int $offset ): string {

    fseek( $fileHandle, $offset );

    $header = $this->readVarInt( $fileHandle );

    $type   = ($header['byte'] >> 4) & 7;

    if( $type === 6 ) {

      return $this->handleOfsDelta( $fileHandle, $offset );

    }

    if( $type === 7 ) {

      return $this->handleRefDelta( $fileHandle );

    }

    $inflator = inflate_init( ZLIB_ENCODING_DEFLATE );

    $result   = '';

    while( !feof( $fileHandle ) ) {

      $chunk = fread( $fileHandle, 8192 );

      $data  = @inflate_add( $inflator, $chunk );

      if( $data !== false ) {

        $result .= $data;

      }

      if(

        $data === false ||

        inflate_get_status( $inflator ) === ZLIB_STREAM_END

      ) {

        break;

      }

    }