)
      TD.getFile(this.photo)
    }
    LinkPreviewTypeAudio.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeAudio)
      this.audio?.audio
    }
    LinkPreviewTypeChannelBoost.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeChannelBoost)
      this.photo?.sizes?.findBiggest()?.photo
    }
    LinkPreviewTypeChat.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeChat)
      this.photo?.sizes?.findBiggest()?.photo
    }
    LinkPreviewTypeDirectMessagesChat.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeDirectMessagesChat)
      this.photo?.sizes?.findBiggest()?.photo
    }
    LinkPreviewTypeDocument.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeDocument)
      this.document.document
    }
    LinkPreviewTypeSticker.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeSticker)
      this.sticker.sticker
    }
    LinkPreviewTypeStickerSet.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeStickerSet)
      this.stickers[0].sticker
    }
    LinkPreviewTypeStory.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeStory)
      null
    }
    LinkPreviewTypeStoryAlbum.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeStoryAlbum)
      null
    }
    LinkPreviewTypeSupergroupBoost.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeSupergroupBoost)
      this.photo?.sizes?.findBiggest()?.photo
    }
    LinkPreviewTypeUser.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeUser)
      this.photo?.sizes?.findBiggest()?.photo
    }
    LinkPreviewTypeVideo.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeVideo)
      this.video?.video
    }
    LinkPreviewTypeVideoNote.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeVideoNote)
      this.videoNote.video
    }
    LinkPreviewTypeVoiceNote.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeVoiceNote)
      this.voiceNote.voice
    }
    // No file returned
    LinkPreviewTypeAlbum.CONSTRUCTOR -> {
      require(this is LinkPreviewTypeAlbum)
      // TODO: pick at least one item?
      null
    }
    LinkPreviewTypeBackground.CONSTRUCTOR,
    LinkPreviewTypeEmbeddedAnimationPlayer.CONSTRUCTOR,
    LinkPreviewTypeEmbeddedAudioPlayer.CONSTRUCTOR,
    LinkPreviewTypeEmbeddedVideoPlayer.CONSTRUCTOR,
    LinkPreviewTypeMessage.CONSTRUCTOR,
    LinkPreviewTypeInvoice.CONSTRUCTOR,
    LinkPreviewTypePremiumGiftCode.CONSTRUCTOR,
    LinkPreviewTypeShareableChatFolder.CONSTRUCTOR,
    LinkPreviewTypeExternalAudio.CONSTRUCTOR,
    LinkPreviewTypeExternalVideo.CONSTRUCTOR,
    LinkPreviewTypeTheme.CONSTRUCTOR,
    LinkPreviewTypeGroupCall.CONSTRUCTOR,
    LinkPreviewTypeVideoChat.CONSTRUCTOR,
    LinkPreviewTypeWebApp.CONSTRUCTOR,
    LinkPreviewTypeUpgradedGift.CONSTRUCTOR,
    LinkPreviewTypeGiftCollection.CONSTRUCTOR,
    LinkPreviewTypeUnsupported.CONSTRUCTOR -> null
    else -> {
      assertLinkPreviewType_4868cb55()
      throw unsupported(this)
    }
  }
}

fun Array<MessageWithProperties>?.findUniqueChatId (): Long {
  if (!this.isNullOrEmpty()) {
    val chatId = this[0].message.chatId
    for (message in this) {
      if (message.message.chatId != chatId) {
        return 0
      }
    }
    return chatId
  }
  return 0
}

fun Array<MessageWithProperties>?.findUniqueSenderId (): MessageSender? {
  if (!this.isNullOrEmpty()) {
    val senderId = this[0].message.senderId
    for (message in this) {


 x 80 以获得更快的检测速度，或者如果您想要检测较远的人脸，如与朋友一起在海滩上，则将其保留为 20 x 20。
*   `searchScaleFactor`：此参数确定要查找多少个不同大小的人脸；通常情况下，如果检测良好，则为`1.1`；如果检测更快，则为`1.2`，这样就不会经常找到人脸。
*   `minNeighbors`：此参数确定检测器应在多大程度上确定它已检测到人脸；它的值通常为 1`3`，但如果您想要更可靠的人脸，即使没有检测到许多人脸，也可以将其设置得更高。
*   `flags`：此参数允许您指定是查找所有面(默认)，还是仅查找最大的面(`CASCADE_FIND_BIGGEST_OBJECT`)。 如果你只寻找最大的脸，它应该跑得更快。 您还可以添加其他几个参数，使检测速度提高约 1%或 2%，如`CASCADE_DO_ROUGH_SEARCH`或`CASCADE_SCALE_IMAGE`。

参数`detectMultiScale()`函数的输出将是参数`cv::Rect`类型对象的参数`std::vector`。 例如，如果它检测到两个面，那么它将在输出中存储一个由两个矩形组成的数组。 `detectMultiScale()`函数的用法如下：

```cpp
    int flags = CASCADE_SCALE_IMAGE; // Search for many faces.
    Size minFeatureSize(20, 20);     // Smallest face size.
    float searchScaleFactor = 1.1f;  // How many sizes to search.
    int minNeighbors = 4;            // Reliability vs many faces.

// Detect objects in the small grayscale image.
std::vector<Rect> faces;
faceDetector.detectMultiScale(img, faces, searchScaleFactor,
                minNeighbors, flags, minFeatureSize);
```

我们可以通过查看存储在矩形向量中的元素数量(即，通过使用`objects.size()`函数)来查看是否检测到任何人脸。

正如前面提到的，如果我们给人脸检测器一个缩小的图像，结果也会缩小，所以如果我们想要看到原始图像的人脸区域，就需要放大它们。 我们还需要确保图像边界上的面完全位于图像内，因为如果发生这种情况，OpenCV 现在将引发异常，如以下代码所示：

```cpp
    // Enlarge the results if the image was temporarily shrunk.
    if (img.cols > scaledWidth) {
      for (auto& object:objects ) {
        object.x = cvRound(object.x * scale);
        object.y = cvRound(object.y * scale);
        object.width = cvRound(object.width * scale);
        object.height = cvRound(object.height * scale);
      }
    }
    // If the object is on a border, keep it in the image.
    for (auto& object:objects) {
      if (object.x < 0)


;border-radius:4px;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff',endColorstr='#fff2f2f2',GradientType=0);*zoom:1;-webkit-box-shadow:0 1px 4px rgba(0,0,0,0.065);-moz-box-shadow:0 1px 4px rgba(0,0,0,0.065);box-shadow:0 1px 4px rgba(0,0,0,0.065)}.navbar-inner:before,.navbar-inner:after{display:table;line-height:0;content:""}.navbar-inner:after{clear:both}.navbar .container{width:auto}.nav-collapse.collapse{height:auto;overflow:visible}.navbar .brand{display:block;float:left;padding:10px 20px 10px;margin-left:-20px;font-size:20px;font-weight:200;color:#777;text-shadow:0 1px 0 #fff}.navbar .brand:hover,.navbar .brand:focus{text-decoration:none}.navbar-text{margin-bottom:0;line-height:40px;color:#777}.navbar-link{color:#777}.navbar-link:hover,.navbar-link:focus{color:#333}.navbar .divider-vertical{height:40px;margin:0 9px;border-right:1px solid #fff;border-left:1px solid #f2f2f2}.navbar .btn,.navbar .btn-group{margin-top:5px}.navbar .btn-group .btn,.navbar .input-prepend .btn,.navbar .input-append .btn,.navbar .input-prepend .btn-group,.navbar .input-append .btn-group{margin-top:0}.navbar-form{margin-bottom:0;*zoom:1}.navbar-form:before,.navbar-form:after{display:table;line-height:0;content:""}.navbar-form:after{clear:both}.navbar-form input,.navbar-form select,.navbar-form .radio,.navbar-form .checkbox{margin-top:5px}.navbar-form input,.navbar-form select,.navbar-form .btn{display:inline-block;margin-bottom:0}.navbar-form input[type="image"],.navbar-form input[type="checkbox"],.navbar-form input[type="radio"]{margin-top:3px}.navbar-form .input-append,.navbar-form .input-prepend{margin-top:5px;white-space:nowrap}.navbar-form .input-append input,.navbar-form .input-prepend input{margin-top:0}.navbar-search{position:relative;float:left;margin-top:5px;margin-bottom:0}.navbar-search .search-query{padding:4px 14px;margin-bottom:0;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:13px;font-weight:normal;line-height:1;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px}.navbar-static-top{position:static;margin-bottom:0}.navbar-static-top .navbar-inner{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.navbar-fixed-top,.navbar-fixed-bottom{position:fixed;right:0;left:0;z-index:1030;margin-bottom:0}.navbar-fixed-top .navbar-inner,.navbar-static-top .navbar-inner{border-width:0 0 1px}.navbar-fixed-bottom .navbar-inner{border-width:1px 0 0}.navbar-fixed-top .navbar-inner,.navbar-fixed-bottom .navbar-inner{padding-right:0;padding-left:0;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.navbar-static-top .container,.navbar-fixed-t


expect(scale.getPixelForValue(0, 3, 0, false)).toBe(199);
		expect(scale.getPixelForValue(0, 3, 0, true)).toBe(199);
	});
});
import { expr2xy, xy2expr } from './alphabet';
import { numberCalc } from './helper';

// Converting infix expression to a suffix expression
// src: AVERAGE(SUM(A1,A2), B1) + 50 + B20
// return: [A1, A2], SUM[, B1],AVERAGE,50,+,B20,+
const infixExprToSuffixExpr = (src) => {
  const operatorStack = [];
  const stack = [];
  let subStrs = []; // SUM, A1, B2, 50 ...
  let fnArgType = 0; // 1 => , 2 => :
  let fnArgOperator = '';
  let fnArgsLen = 1; // A1,A2,A3...
  let oldc = '';
  for (let i = 0; i < src.length; i += 1) {
    const c = src.charAt(i);
    if (c !== ' ') {
      if (c >= 'a' && c <= 'z') {
        subStrs.push(c.toUpperCase());
      } else if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || c === '.') {
        subStrs.push(c);
      } else if (c === '"') {
        i += 1;
        while (src.charAt(i) !== '"') {
          subStrs.push(src.charAt(i));
          i += 1;
        }
        stack.push(`"${subStrs.join('')}`);
        subStrs = [];
      } else if (c === '-' && /[+\-*/,(]/.test(oldc)) {
        subStrs.push(c);
      } else {
        // console.log('subStrs:', subStrs.join(''), stack);
        if (c !== '(' && subStrs.length > 0) {
          stack.push(subStrs.join(''));
        }
        if (c === ')') {
          let c1 = operatorStack.pop();
          if (fnArgType === 2) {
            // fn argument range => A1:B5
            try {
              const [ex, ey] = expr2xy(stack.pop());
              const [sx, sy] = expr2xy(stack.pop());
              // console.log('::', sx, sy, ex, ey);
              let rangelen = 0;
              for (let x = sx; x <= ex; x += 1) {
                for (let y = sy; y <= ey; y += 1) {
                  stack.push(xy2expr(x, y));
                  rangelen += 1;
                }
              }
              stack.push([c1, rangelen]);
            } catch (e) {
              // console.log(e);
            }
          } else if (fnArgType === 1 || fnArgType === 3) {
            if (fnArgType === 3) stack.push(fnArgOperator);
            // fn argument => A1,A2,B5
            stack.push([c1, fnArgsLen]);
            fnArgsLen = 1;
          } else {
            // console.log('c1:', c1, fnArgType, stack, operatorStack);
            while (c1 !== '(') {
              stack.push(c1);
              if (operatorStack.length <= 0) break;
              c1 = operatorStack.pop();
            }
          }
          fnArgType = 0;
        } else if (c === '=' || c === '>' || c === '<') {
          const nc = src.charAt(i + 1);
          fnArgOperator = c;
          if (nc === '=' || nc === '-') {
            fnArgOperator += nc;
            i += 1;
          }
          fnArgType = 3;
        } else if (c === ':') {
          fnArgType = 2;
        } else if (c === ',') {
          if (fnArgType === 3) {
            stack.push(fnArgO


e76\u786e\u5b9a\uff0c\u5c06\u5168\u56fd417\u6240\u9ad8\u6821\uff0c\u4fdd\u7559309\u6240\uff0c\u5408\u5e7643\u6240\uff0c\u64a4\u950045\u6240\uff0c\u6539\u4e3a\u4e2d\u4e1317\u6240\uff0c\u6539\u4e3a\u5de5\u53823\u6240\uff0c\u589e\u8bbe7\u6240\u3002", "type": "paragraph"}]}
  </script>

    [返回索引页面]

   中共中央关于高等院校下放问题的通知（概要）

   日期：1969-10-26 作者：[待确定]

   中国共产党中央委员会1969年10月26日发出《关于高等院校下放问题的通知》（以下简称《通知》）。《通知》的主要内容是：国务院各部门所属的高等院校（包括半工半读、函授学校），设在北京的仍归各有关部门领导；设在外地的，可交由当地省、市、自治区革命委员会领导；与厂矿结合办校的，也可交由厂矿革命委员会领导；设在其它地方的，交由当地省、市、自治区革命委员会领导。教育部所属的高等院校（包括函授学校），全部交由所在省、市、自治区革命委员会领导。高等院校在本校所在省、市、自治区以外设有分校或教改机构的，则实行以总校为主、当地革命委员会为辅的双重领导。下放给地方的高等院校，除了为当地培养人才外，还要为国家培养人材，因此，学校的招生和毕业生的分配，都纳入国家计划。《通知》实施后到1971年止，全国原有高等院校434所保留继续办的还有328所，其中原中央部署高等院校176所，经调整后，保留下来31所。第二、三、四、五、六机械工业部所属军事工业院校实行部门与地方双重领导，以地方为主的管理体制，仍由中央有关部门领导的还剩下6所。1971年1月31日，国务院科教组、国家计委向国务院提出《关于高等院校调整问题的报告》（以下简称《报告》）。8月13日，中共中央同意《报告》提出的调整方案。根据此《报告》方案，规定高等院校的管理体制是：在中央统一计划下，实行以“块块为主”（多数院校由地方领导）；部分院校由地方和中央部门双重领导，以地方为主；少数院校由中央部门直接领导。并确定，将全国417所高校，保留309所，合并43所，撤销45所，改为中专17所，改


ayer.map.y
				Returns the map for this layer if it exists, or nil if it doesn't (ie if it isn't a map layer). For flixel users it's worth noting that the map is a FlxTilemap and so you can work directly with the map data from that.

				layer.map.widthInTiles
				The width of the map in tiles.

				layer.map.heightInTiles
				The height of the map in tiles.

				layer.map.width
				The width of the map in pixels.

				layer.map.height
				The height of the map in pixels.

				layer.map.tileWidth
				The width in pixels of each tile in the map.

				layer.map.tileHeight
				The height in pixels of each tile in the map.

				layer.map.drawIndex
				The index of the first drawn tile on the map.

				layer.map.collideIndex
				The index of the first collidable tile on the map.

				layer.map.tileSpacingX
				The width of each tile for the collisions. Ie a 2.5d block may be drawn larger than the base tile spacing size.

				layer.map.tileSpacingY
				The base tile height of each tile for the collisions. Ie a 2.5d block may be drawn larger than the base tile spacing size.

				layer.map.tileOffsetX
				The number of pixels each row is offset by.

				layer.map.tileOffsetY
				The number of pixels each column is offset by.

				layer.map.xStagger
				How much every other row is offset by.

				layer.map.tilesStartX
				Where the rendering of the tiles actually starts from the left of the bitmap.

				layer.map.tilesStartY
				Where the rendering of the tiles actually starts from the top of the bitmap.

				layer.map.stackHeight
				When using stacked tiles this is the number of pixels each tile within the stack is offset by.

				layer.map.numStackedTiles
				The number of tiles within a tile stack.

				layer.HasHits
				true if the map layer should have hits.

				layer.properties
				The properties for this layer. Use DAME.GetTextForProperties to parse this data.

				layer.imageFile
				The image file for this layer. Mainly used for map layers.


/male-to-male-servo-extension-cable-twisted-22awg-jr-style-5-pcs.html)
- [USB-C extension cable](https://www.digitec.ch/en/s1/product/powerguard-usb-c-usb-c-025-m-usb-cables-22529949?dbq=1&gclid=Cj0KCQjw2cWgBhDYARIsALggUhrh-z-7DSU0wKfLBVa8filkXLQaxUpi7pC0ffQyRzLng8Ph01h2R1gaAp0mEALw_wcB&gclsrc=aw.ds)
- [3M VHB tape](https://www.amazon.in/3M-VHB-Tape-4910-Length/dp/B00GTABM3Y)
- [3D-Printed mounts](https://github.com/PX4/PX4-user_guide/raw/main/assets/airframes/vtol/omp_hobby_zmo_fpv/omp_hobby_zmo_3d_prints.zip)
  - 2x wing connector mount
  - 1x Airspeed sensor mount
  - 1x GPS-Mount
  - 1x Lidar-Mount
  - 1x Skynode mount
- [USB camera (included in Skynode dev kit)](https://www.amazon.com/ELP-megapixel-surveillance-machine-monitor/dp/B015FIKTZC)
- Screws, inserts, heat shrink, etc.

## Tools

The following tools were used for this build.

- Hex driver set
- Wrench set
- Soldering station
- Glue: Hot glue, 5 min Epoxy
- Tape
- 3M Double sided tape ([3M VHB tape](https://www.amazon.in/3M-VHB-Tape-4910-Length/dp/B00GTABM3Y))
- Sandpaper
- 3D-Printer

## Hardware Integration

### Preparations

Remove the original flight controller, ESC and wing connector cables. Also remove the the propellers. This will help you with the handling of the vehicle and will reduce the risk of an injury due to an unintentional motor startup.

ZMO FPV in it's original state.

![ZMO FPV in it's original state](../../assets/airframes/vtol/omp_hobby_zmo_fpv/zmo-01.jpg)

Flight controller and wing connectors removed from the vehicle.

![ZMO FPV with FC and wing connectors removed](../../assets/airframes/vtol/omp_hobby_zmo_fpv/zmo-02.jpg)

### ESCs

1. Unsolder the ESC PWM-signal and ground pins and solder some servo extension wire to the pins. The cable should be long enough to connect the wire to the FMU pins of the flight controller.
1. Unsolder the 3 female banana plug connectors of the rear motor (might not be necessary for the Pixhawk 6 integration).
1. Screw the ESC back in place with 4 M2.5 x 12 screws.
1. Shorten the rear motor wires and solder them as shown in the picture into place.
1. Solder signal and GND wires to the PWM input ot the ESC.

   ![ESC 01](../../assets/airframes/vtol/omp_hobby_zmo_fpv/esc-01.jpg)

1. Remove the female banana plug on the ESC. This will give you more space to install the flight controller.

   ![ESC 02](../../assets/airframes/vtol/omp_hobby_zmo_fpv/esc-02.jpg)

1. Solder the rear motor wires to the ESC. Make sure to connect such that the motor spins in the correct direction.

   ![ESC 03](../../assets/airframes/vtol/omp_hobby_zmo_fpv/esc-03.jpg)

### Wing Connector

To directly connect the wing connector when the wing gets attached, some 3D-printed mounts are needed to center the connector. This step is not essential, but makes the handling much easier


esponse: Response?, throwable: Throwable?) {
                // TODO add hotfix for Classrooms 500
                data.error(ApiError(tag, ERROR_REQUEST_FAILURE)
                        .withResponse(response)
                        .withThrowable(throwable))
            }
        }

        Request.builder()
                .url("${if (data.fakeLogin) FAKE_LIBRUS_API else LIBRUS_API_URL}/$endpoint")
                .userAgent(LIBRUS_USER_AGENT)
                .addHeader("Authorization", "Bearer ${data.apiAccessToken}")
                .apply {
                    when (method) {
                        GET -> get()
                        POST -> post()
                    }
                    if (payload != null)
                        setJsonBody(payload)
                }
                .allowErrorCode(HTTP_BAD_REQUEST)
                .allowErrorCode(HTTP_FORBIDDEN)
                .allowErrorCode(HTTP_UNAUTHORIZED)
                .allowErrorCode(HTTP_UNAVAILABLE)
                .allowErrorCode(HTTP_NOT_FOUND)
                .allowErrorCode(503)
                .callback(callback)
                .build()
                .enqueue()
    }
}
/*
 * Copyright (c) Kacper Ziubryniewicz 2019-11-20
 */

package pl.szczodrzynski.edziennik.data.api.edziennik.librus.data.api

import pl.szczodrzynski.edziennik.data.api.edziennik.librus.DataLibrus
import pl.szczodrzynski.edziennik.data.api.edziennik.librus.ENDPOINT_LIBRUS_API_NORMAL_GRADE_COMMENTS
import pl.szczodrzynski.edziennik.data.api.edziennik.librus.data.LibrusApi
import pl.szczodrzynski.edziennik.data.db.entity.GradeCategory
import pl.szczodrzynski.edziennik.data.db.entity.SYNC_ALWAYS
import pl.szczodrzynski.edziennik.ext.*

class LibrusApiGradeComments(override val data: DataLibrus,
                             override val lastSync: Long?,
                             val onSuccess: (endpointId: Int) -> Unit
) : LibrusApi(data, lastSync) {
    companion object {
        const val TAG = "LibrusApiGradeComments"
    }

    init {
        apiGet(TAG, "Grades/Comments") { json ->

            json.getJsonArray("Comments")?.asJsonObjectList()?.forEach { comment ->
                val id = comment.getLong("Id") ?: return@forEach
                val text = comment.getString("Text")?.fixWhiteSpaces() ?: return@forEach

                val gradeCategoryObject = GradeCategory(
                        profileId,
                        id,
                        -1f,
                        -1,
                        text
                ).apply {
                    type = GradeCategory.TYPE_NORMAL_COMMENT
                }

                data.gradeCategories.put(id, gradeCategoryObject)
            }

            data.setSyncNext(ENDPOINT_LIBRUS_API_NORMAL_GRADE_COMMENTS, SYNC_ALWAYS)
            onSuccess(ENDPOINT_LIBRUS_API_NORMAL_GRADE_COMMENTS)
        }
    }
}
/*
 * Copyright (c) Kuba Szczodrzyński 2019-10-23.
 */

package pl.szczodrzynski.edziennik.data.api.edziennik.librus.data.api

import pl.szczodrzynski.edziennik.*
import pl.szczodrzynski.edziennik.data.api.edziennik.librus.DataLibrus
import pl.szczodrzynski.edziennik.data.api.edziennik.librus.ENDPOINT_LIBRUS_API_UNITS
import pl.szczodrzynski.edziennik.data.api.edziennik.librus.data.LibrusApi
import pl.szczodrzynski.edziennik.ext.*

class LibrusApiUnits(override val data: DataLibrus,
                     override val lastSync: Long?,
                     val onSuccess: (endpointId: Int) -> Unit
) : LibrusApi(data, lastSync) {
    companion object {
        const val TAG = "LibrusApiUnits"
    }

    init { run {
        if (data.unitId == 0L)


 & = \\sigma(y-x) {Esc:\\\\}
\\dot{y} & = \\rho x - y - xz {Esc:\\\\}
\\dot{z} & = -\\beta z + xy
\\end{aligned}
{maBB:\\\\]}}}
`
);
export interface IHash<T> {
    [key: string]: T;
}

export interface HashMapInterface<T> {
    // map: IHash<T>;
    size: number;
    get(key: string): T;
    put(key: string, value: T): HashMapInterface<T>;
    contains(key: string): boolean;
    remove(key: string): HashMapInterface<T>;
    removeAll(): HashMapInterface<T>;
    getKeys(): string[];
    getValues(): T[];
}
namespace Ui {

    interface GridCol {
        auto: boolean;
        star: boolean;
        absolute: boolean;
        actualWidth: number;
        offset: number;
        width: number;
    }

    interface GridRow {
        auto: boolean;
        star: boolean;
        absolute: boolean;
        actualHeight: number;
        offset: number;
        height: number;
    }

    export interface GridInit extends ContainerInit {
        cols?: string;
        rows?: string;
    }

    export class Grid extends Container implements GridInit {

        private _cols: GridCol[];
        private _rows: GridRow[];

        constructor(init?: GridInit) {
            super(init);
            this._cols = [{ auto: true, star: false, absolute: false, actualWidth: 0, offset: 0, width: 0 }];
            this._rows = [{ auto: true, star: false, absolute: false, actualHeight: 0, offset: 0, height: 0 }];
            if (init) {
                if (init.cols !== undefined)
                    this.cols = init.cols;
                if (init.rows !== undefined)
                    this.rows = init.rows;
            }
        }

        set cols(colsDef: string) {
            this._cols = [];
            let cols = colsDef.split(',');
            for (let i = 0; i < cols.length; i++) {
                let col = cols[i];
                if (col == 'auto')
                    this._cols.push({ auto: true, star: false, absolute: false, actualWidth: 0, offset: 0, width: 0 });
                else if (col == '*')
                    this._cols.push({ auto: false, star: true, absolute: false, actualWidth: 0, offset: 0, width: 1 });
                else if (col.match(/^[0-9]+\.?[0-9]*\*$/))
                    this._cols.push({ auto: false, star: true, absolute: false, actualWidth: 0, offset: 0, width: parseInt(col.slice(0, col.length - 1)) });
                else if (col.match(/^[0-9]+$/))
                    this._cols.push({ auto: false, star: false, absolute: true, actualWidth: 0, offset: 0, width: parseInt(col) });
                else if (DEBUG)
                    throw ('Ui.Grid column definition "' + col + '" not supported');
            }
            //this.invalidateMeasure();
        }

        set rows(rowsDef: string) {
            this._rows = [];
            let rows = rowsDef.split(',');
            for (let i = 0; i < rows.length; i


/*
 * MIT License
 *
 * Copyright (C) 2021-2023 by wangwenx190 (Yuhang Zhao)
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#pragma once

#include <QtGui/qwindow.h>
#include <FramelessHelper/Quick/framelesshelperquick_global.h>

class QuickSettings : public QObject
{
    Q_OBJECT
#ifdef QML_NAMED_ELEMENT
    QML_NAMED_ELEMENT(Settings)
#endif
#ifdef QML_SINGLETON
    QML_SINGLETON
#endif
    Q_DISABLE_COPY(QuickSettings)

public:
    explicit QuickSettings(QObject *parent = nullptr);
    ~QuickSettings() override;

public Q_SLOTS:
    void saveGeometry(QWindow *window);
    Q_NODISCARD bool restoreGeometry(QWindow *window);
};


ture = "memory")]
impl<'a> std::ops::Deref for MemFile<'a> {
    type Target = File;
    fn deref(&self) -> &Self::Target {
        &self.file
    }
}

#[cfg(feature = "memory")]
impl<'a> MemFile<'a> {
    /// Open a file from the given buffer
    pub fn new(name: Option<&str>, mem: &'a [u8]) -> error::Result<Self> {
        let cstr = std::ffi::CString::new(name.unwrap_or("/")).unwrap();
        let mut ncid = 0;
        unsafe {
            let _l = LOCK.lock().unwrap();
            error::checked(nc_open_mem(
                cstr.as_ptr(),
                NC_NOWRITE,
                mem.len(),
                mem.as_ptr() as *const u8 as *mut _,
                &mut ncid,
            ))?;
        }

        let root = parse_file(ncid)?;

        Ok(Self {
            file: File {
                name: name.unwrap_or("").to_string(),
                ncid,
                root,
            },
            _buffer: std::marker::PhantomData,
        })
    }
}

impl Drop for File {
    fn drop(&mut self) {
        unsafe {
            let _g = LOCK.lock().unwrap();
            // Can't really do much with an error here
            let _err = error::checked(nc_close(self.ncid));
        }
    }
}

use super::dimension::Dimension;

fn get_group_dimensions(
    ncid: nc_type,
    unlimited_dims: &[nc_type],
) -> error::Result<HashMap<String, Dimension>> {
    let mut ndims: nc_type = 0;
    unsafe {
        error::checked(nc_inq_dimids(ncid, &mut ndims, std::ptr::null_mut(), 0))?;
    }

    if ndims == 0 {
        return Ok(HashMap::new());
    }
    let mut dimids = vec![0 as nc_type; ndims.try_into()?];
    unsafe {
        error::checked(nc_inq_dimids(
            ncid,
            std::ptr::null_mut(),
            dimids.as_mut_ptr(),
            0,
        ))?;
    }

    let mut dimensions = HashMap::with_capacity(ndims.try_into()?);
    let mut buf = [0_u8; NC_MAX_NAME as usize + 1];
    for dimid in dimids {
        for i in buf.iter_mut() {
            *i = 0
        }
        let mut len = 0;
        unsafe {
            error::checked(nc_inq_dim(
                ncid,
                dimid as _,
                buf.as_mut_ptr() as *mut _,
                &mut len,
            ))?;
        }

        let zero_pos = buf
            .iter()
            .position(|&x| x == 0)
            .unwrap_or_else(|| buf.len());
        let name = String::from(String::from_utf8_lossy(&buf[..zero_pos]));

        let len = if unlimited_dims.contains(&dimid) {
            None
        } else {
            Some(unsafe { core::num::NonZeroUsize::new_unchecked(len) })
        };
        dimensions.insert(
            name.clone(),
            Dimension {
                ncid,
                name,
                len,
                id: dimid,
            },
        );
    }

    Ok(dimensions)
}

use super::attribute::Attribute;
fn get_attributes(ncid: nc_type, varid: nc_type) -> error::Result<HashMap<String, Attribute>> {
    let mut natts = 0;
    unsafe {
        error::checked(nc_inq_varnatts(ncid, varid, &


**************************************
 *************************************************/

/*************************************************
*          Decode byte-string in base 64         *
*************************************************/

/* This function decodes a string in base 64 format as defined in RFC 2045
(MIME) and required by the SMTP AUTH extension (RFC 2554). The decoding
algorithm is written out in a straightforward way. Turning it into some kind of
compact loop is messy and would probably run more slowly.

Arguments:
  code        points to the coded string, zero-terminated
  ptr         where to put the pointer to the result, which is in
              allocated store, and zero-terminated

Returns:      the number of bytes in the result,
              or -1 if the input was malformed

Whitespace in the input is ignored.
A zero is added on to the end to make it easy in cases where the result is to
be interpreted as text. This is not included in the count. */

static uschar dec64table[] = {
  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, /*  0-15 */
  255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, /* 16-31 */
  255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63, /* 32-47 */
   52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,255,255,255, /* 48-63 */
  255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, /* 64-79 */
   15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255, /* 80-95 */
  255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 96-111 */
   41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255  /* 112-127*/
};

int
b64decode(const uschar *code, uschar **ptr)
{

int x, y;
uschar *result;

{
  int l = Ustrlen(code);
  *ptr = result = store_get(1 + l/4 * 3 + l%4);
}

/* Each cycle of the loop handles a quantum of 4 input bytes. For the last
quantum this may decode to 1, 2, or 3 output bytes. */

while ((x = *code++) != 0)
  {
  if (isspace(x)) continue;
  /* debug_printf("b64d: '%c'\n", x); */

  if (x > 127 || (x = dec64table[x]) == 255) return -1;

  while (isspace(y = *code++)) ;
  /* debug_printf("b64d: '%c'\n", y); */
  if (y > 127 || (y = dec64table[y]) == 255)
    return -1;

  *result++ = (x << 2) | (y >> 4);
  /* debug_printf("b64d:      -> %02x\n", result[-1]); */

  while (isspace(x = *code++)) ;
  /* debug_printf("b64d: '%c'\n", x); */
  if (x == '=')		/* endmarker, but there should be another */
    {
    while (isspace(x = *code++)) ;
    /* debug_printf("b64d: '%c'\n", x); */
    if (x != '=') return -1;
    while (isspace(y = *code++)) ;
    if (y != 0) return -1;
    /* debug_printf("b64d: DONE\n"); */
    break;
    }
  else
    {
    if (x > 127 || (x = dec64table[x]) == 255) return -1;
    *result++ = (y << 4) | (x >> 2);
    /* debug_printf("b64d:      -> %02x\n", result[-1]); */

    while (isspace(y = *code++)) ;
    /* debug_printf("b64d: '%c'\n", y); */
    if (y == '=')
      {
      while (isspace(y = *code++)) ;
      if (y != 0) return -1;
      /* debug_printf("b64d: DONE\n"); */
      break;
      }
    else
      {
      if (y > 127 || (y = dec64table[y]) == 255) return -1;
      *result++ = (x << 6) | y;
      /* debug_printf("b64d:      -> %02x\n", result[-1]); */
      }
    }
  }

*result = 0;
return result - *ptr;
}

/*************************************************
*          Encode byte-string in base 64         *
*************************************************/

/* This function encodes a string of bytes, containing any values whatsoever,
in base 64 as defined in RFC 2045 (MIME) and required by the SMTP AUTH
extension (RFC 2554). The encoding algorithm is written out in a
straightforward way. Turning it into some kind of compact loop is messy and
would probably run more slowly.

Arguments:
  clear       points to the clear text bytes
  len         the number of bytes to encode

Returns:      a pointer to the zero-terminated base 64 string, which
              is in working store
*/

static uschar *enc64table =
  US"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

uschar *
b64encode(uschar *clear, int len)
{
uschar *code = store_get(4*((len+2)/3) + 1);
uschar *p = code;

while (len-- >0)
  {
  int x, y;

  x = *clear++;
  *p++ = enc64table[(x >> 2) & 63];

  if (len-- <= 0)
    {
    *p++ = enc64table[(x << 4) & 63];
    *p++ = '=';
    *p++ = '=';
    break;
    }

  y = *clear++;
  *p++ = enc64table[((x << 4) | ((y >> 4) & 15)) & 63]


using System;
using System.Collections.Generic;
using Bogus;
using Soenneker.Reflection.Cache.Types;
using Soenneker.Utils.AutoBogus.Config;
using Soenneker.Utils.AutoBogus.Override;
using Soenneker.Utils.AutoBogus.Services;

namespace Soenneker.Utils.AutoBogus.Context;

/// <summary>
/// A class that provides context for a generate request. A 'generate request' is a single call to `.Generate()` for example.
/// </summary>
public sealed class AutoFakerContext
{
    /// <summary>
    /// The parent type of the type associated with the current generate request.
    /// </summary>
    public CachedType? ParentType;

    /// <summary>
    /// Possible null reference if <see cref="CachedType"/> is null, but remaining as non-nullable for <see cref="AutoFakerOverride{T}"/> warnings.
    /// </summary>
    public Type GenerateType => CachedType?.Type!;

    /// <summary>
    /// The type associated with the current generate request.
    /// </summary>
    public CachedType? CachedType { get; set; }

    /// <summary>
    /// The name associated with the current generate request.
    /// </summary>
    public string? GenerateName;

    /// <summary>
    /// The underlying <see cref="Bogus.Faker"/> instance used to generate random values.
    /// </summary>
    public readonly Faker Faker;

    public readonly AutoFakerConfig Config;

    p


#Description: A program that returns the FizzBuzz patern - 1 - 100 with Fizz replacing all
#            multiples of 5, Buzz replacing multiples of 8 and FizzBuzz replacing multiples of 8 and 5.
#Author: Group 22(DCE, NP)
#Date: June 17 -26

#No inputs, no functions, only output

def main():

    Mess_List = []
    turns =1
    x = [1,2,3,4]
    while turns < 101:
        if (turns % 5) == 0 and (turns % 8) == 0:
            message = "FizzBuzz"
        elif (turns % 8) == 0:
            message = "Buzz"
        elif (turns % 5) == 0:
            message = "Fizz"
        else:
            message = turns
        Mess_List.append(message)
        turns += 1
    print()
    print()  #The output was put into 5 columns simply to save screen space
    print()
    print ("THE FIZZBUZZ SOLUTION:")
    print ("(1 - 20)      (21 - 40)      (41 - 60)      (61 - 80)      (81 - 100)")
    print()
    for i in range(0,20):

        print (f"   {Mess_List[i]:<8}       {Mess_List[x[0]*20+i]:<8}       {Mess_List[x[1]*20+i]:<8}       {Mess_List[x[2]*20+i]:<8}       {Mess_List[x[3]*20+i]:<8}")
        i += 1
    print()
    print()
    print()
    print ("Running Fizzbuzz.")

if __name__ == "__main__":
    main()


/*
 *	linux/arch/alpha/kernel/irq_pyxis.c
 *
 * Based on code written by David A Rusling (david.rusling@reo.mts.dec.com).
 *
 * IRQ Code common to all PYXIS core logic chips.
 */

#include <linux/init.h>
#include <linux/sched.h>
#include <linux/irq.h>

#include <asm/io.h>
#include <asm/core_cia.h>

#include "proto.h"
#include "irq_impl.h"

/* Note mask bit is true for ENABLED irqs.  */
static unsigned long cached_irq_mask;

static inline void
pyxis_update_irq_hw(unsigned long mask)
{
	*(vulp)PYXIS_INT_MASK = mask;
	mb();
	*(vulp)PYXIS_INT_MASK;
}

static inline void
pyxis_enable_irq(unsigned int irq)
{
	pyxis_update_irq_hw(cached_irq_mask |= 1UL << (irq - 16));
}

static void
pyxis_disable_irq(unsigned int irq)
{
	pyxis_update_irq_hw(cached_irq_mask &= ~(1UL << (irq - 16)));
}

static unsigned int
pyxis_startup_irq(unsigned int irq)
{
	pyxis_enable_irq(irq);
	return 0;
}

static void
pyxis_end_irq(unsigned int irq)
{
	if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
		pyxis_enable_irq(irq);
}

static void
pyxis_mask_and_ack_irq(unsigned int irq)
{
	unsigned long bit = 1UL << (irq - 16);
	unsigned long mask = cached_irq_mask &= ~bit;

	/* Disable the interrupt.  */
	*(vulp)PYXIS_INT_MASK = mask;
	wmb();
	/* Ack PYXIS PCI interrupt.  */
	*(vulp)PYXIS_INT_REQ = bit;
	mb();
	/* Re-read to force both writes.  */
	*(vulp)PYXIS_INT_MASK;
}

static struct hw_interrupt_type pyxis_irq_type = {
	.typename	= "PYXIS",
	.startup	= pyxis_startup_irq,
	.shutdown	= pyxis_disable_irq,
	.enable		= pyxis_enable_irq,
	.disable	= pyxis_disable_irq,
	.ack		= pyxis_mask_and_ack_irq,
	.end		= pyxis_end_irq,
};

void
pyxis_device_interrupt(unsigned long vector)
{
	unsigned long pld;
	unsigned int i;

	/* Read the interrupt summary register of PYXIS */
	pld = *(vulp)PYXIS_INT_REQ;
	pld &= cached_irq_mask;

	/*
	 * Now for every possible bit set, work through them and call
	 * the appropriate interrupt handler.
	 */
	while (pld) {
		i = ffz(~pld);
		pld &= pld - 1; /* clear least bit set */
		if (i == 7)
			isa_device_interrupt(vector);
		else
			handle_irq(16+i);
	}
}

void __init
init_pyxis_irqs(unsigned long ignore_mask)
{
	long i;

	*(vulp)PYXIS_INT_MASK = 0;		/* disable all */
	*(vulp)PYXIS_INT_REQ  = -1;		/* flush all */
	mb();

	/* Send -INTA pulses to clear any pending interrupts ...*/
	*(vuip) CIA_IACK_SC;

	for (i = 16; i < 48; ++i) {
		if ((ignore_mask >> i) & 1)
			continue;
		irq_desc[i].status = IRQ_DISABLED | IRQ_LEVEL;
		irq_desc[i].chip = &pyxis_irq_type;
	}

	setup_irq(16+7, &isa_cascade_irqaction);
}


   关于峨嵋山佛教徒自我改造回报会情况反映

   日期：1959-3-13 作者：乐山地委统战部

   乐山地委统战部

   （上缺）些错误思想与看法，交流了自我改造的经验，从实践证明，通过劳动实践是改造政治立场、建立劳动人民感情的正确重要途经之一。现就会议反映出的几个问题述说如后：

   一、对政治立场自我改造方面几个思想认识

   （一）有些人抱着“镀金思想”，自以为“已改造好了”：洪椿坪圣全在检查自我改造规划时说：“从解放那天起，我一直就是接受党的领导，走社会主义道路了。”洗象池永崇把自己不是反革命作为证明已接受党的领导的“理由”。大峨寺宣怀说：“爱国，家都舍了，怎么说和尚不爱国呢。”有的认为：“我挑的比农民两人抬的还多”从而证明自己改造好了。特别一部分青年和尚认为“改造”是受了“冤枉”，九老洞永常说：“在佛教团体背了‘改造’的名誉，我年青也没有剥削谁，出身就是在贫苦劳动家庭，有啥改造的？”并借此要求还俗。中心寺圣能说：“我还俗有劳力又拿到钱，又不随时提改造问题了。”

   （二）劳动是为了钱，“为钱生存”的资产阶级思想突出反映：青音阁圣殊说：“活路要干，钱不发，还不如劳改犯。”卧云庵当家永喜说：“劳动钱又少，拿多少钱干多少活，能担100只担80斤。”九老洞常宣更加露骨的说：“我的劳动只不过是为了钱，工人、农民、干部劳动都有报酬，所以才放出卫星，劳动没报酬这是矛盾。”并说：“从59年起，每月3、4元，这不是资产阶级思想，否则，不能保证干劲。”

   （三）公开威协，厌倦和抵触改造：“有些人认为劳动是强制佛教徒干的，太


: true);
    }

    try {
      return DateTime.parse(timestamp).toUtc();
    } catch (e) {
      // 解析失败，返回Unix纪元时间
      return DateTime.fromMillisecondsSinceEpoch(0, isUtc: true);
    }
  }

  /// 安全地比较两个时间戳
  /// 返回值：
  /// - 正数：remote 更新
  /// - 负数：local 更新
  /// - 0：时间戳相同
  static int compareTimestamps(
      String? localTimestamp, String? remoteTimestamp) {
    final localTime = parseTimestamp(localTimestamp);
    final remoteTime = parseTimestamp(remoteTimestamp);

    return remoteTime.compareTo(localTime);
  }

  /// 判断remote是否比local更新
  /// null 时间戳被视为最旧的时间戳
  static bool shouldUseRemote(String? localTimestamp, String? remoteTimestamp) {
    return compareTimestamps(localTimestamp, remoteTimestamp) > 0;
  }

  /// 判断local是否比remote更新或相等
  static bool shouldKeepLocal(String? localTimestamp, String? remoteTimestamp) {
    return compareTimestamps(localTimestamp, remoteTimestamp) <= 0;
  }

  /// 生成当前时间戳字符串
  static String generateTimestamp() {
    return DateTime.now().toUtc().toIso8601String();
  }

  /// 检查时间戳是否为默认值（表示从未同步过）
  static bool isDefaultTimestamp(String? timestamp) {
    if (timestamp == null || timestamp.isEmpty) return true;

    final parsed = parseTimestamp(timestamp);
    final defaultTime = parseTimestamp(_defaultTimestamp);

    return parsed.isAtSameMomentAs(defaultTime);
  }

  /// 格式化时间戳用于显示
  static String formatTimestamp(String? timestamp) {
    if (timestamp == null || timestamp.isEmpty) {
      return '未知时间';
    }

    try {
      final dateTime = DateTime.parse(timestamp);
      final now = DateTime.now();
      final difference = now.difference(dateTime);

      if (difference.inDays > 0) {
        return '${difference.inDays}天前';
      } else if (difference.inHours > 0) {
        return '${difference.inHours}小时前';
      } else if (difference.inMinutes > 0) {
        return '${difference.inMinutes}分钟前';
      } else {
        return '刚刚';
      }
    } catch (e) {
      return '时间格式错误';
    }
  }

  /// 检测可能的时钟偏移
  /// 如果remote时间戳比当前时间超前过多，可能存在时钟偏移
  static Duration? detectClockSkew(String? remoteTimestamp) {
    if (remoteTimestamp == null || remoteTimestamp.isEmpty) {
      return null;
    }

    try {
      final remoteTime = DateTime.parse(remoteTimestamp).toUtc();
      final now = DateTime.now().toUtc();
      final difference = remoteTime.difference(now);

      // 如果remote时间戳超前当前时间5分钟以上，认为可能存在时钟偏移
      if (difference.inMinutes > 5) {
        return difference;
      }

      return null;
    } catch (e) {
      return null;
    }
  }

  /// 验证时间戳格式是否正确
  static bool isValidTimestamp(String? timestamp) {
    if (timestamp == null || timestamp.isEmpty) {
      return false;
    }

    try {
      DateTime.parse(timestamp);
      return true;
    } catch (e) {
      return false;
    }
  }

  /// 标准化时间戳格式（转换为UTC ISO86


					continue ;
				currentIndex++ ;
				if ( currentIndex == target )
				{
					cursor = candidate ;
					break ;
				}
			}
			if ( currentIndex < target )
				return null ;
		}
		else
		{
			if ( i != bookmark.length - 1 )
				return null ;
			while ( target >= cursor.length && cursor.nextSibling && cursor.nextSibling.nodeType == 3 )
			{
				target -= cursor.length ;
				cursor = cursor.nextSibling ;
			}
			cursor = cursor.nodeValue.charAt( target ) ;
			if ( cursor == "" )
				cursor = null ;
		}
	}
	return cursor ;
}

// With this function, we can treat the bookmark as an iterator for DFS.
function NextPosition( bookmark )
{
	// See if there's anything further down the tree.
	var next = bookmark.concat( [0] ) ;
	if ( GetData( next ) != null )
		return next ;

	// Nothing down there? See if there's anything next to me.
	var next = bookmark.slice( 0, bookmark.length - 1 ).concat( [ bookmark[ bookmark.length - 1 ] + 1 ] ) ;
	if ( GetData( next ) != null )
		return next ;

	// Nothing even next to me? See if there's anything next to my ancestors.
	for ( var i = bookmark.length - 1 ; i > 0 ; i-- )
	{
		var next = bookmark.slice( 0, i - 1 ).concat( [ bookmark[ i - 1 ] + 1 ] ) ;
		if ( GetData( next ) != null )
			return next ;
	}

	// There's absolutely nothing left to walk, return null.
	return null ;
}

// Is this character a unicode whitespace?
// Reference: http://unicode.org/Public/UNIDATA/PropList.txt
function CheckIsWhitespace( c )
{
	var code = c.charCodeAt( 0 );
	if ( code >= 9 && code <= 0xd )
		return true;
	if ( code >= 0x2000 && code <= 0x200a )
		return true;
	switch ( code )
	{
		case 0x20:
		case 0x85:
		case 0xa0:
		case 0x1680:
		case 0x180e:
		case 0x2028:
		case 0x2029:
		case 0x202f:
		case 0x205f:
		case 0x3000:
			return true;
		default:
			return false;
	}
}

// Knuth-Morris-Pratt Algorithm for stream input
KMP_NOMATCH = 0 ;
KMP_ADVANCED = 1 ;
KMP_MATCHED = 2 ;
function KmpMatch( pattern, ignoreCase )
{
	var overlap = [ -1 ] ;
	for ( var i = 0 ; i < pattern.length ; i++ )
	{
		overlap.push( overlap[i] + 1 ) ;
		while ( overlap[ i + 1 ] > 0 && pattern.charAt( i ) != pattern.charAt( overlap[ i + 1 ] - 1 ) )
			overlap[ i + 1 ] = overlap[ overlap[ i + 1 ] - 1 ] + 1 ;
	}
	this._Overlap = overlap ;
	this._State = 0 ;
	this._IgnoreCase = ( ignoreCase === true ) ;
	if ( ignoreCase )
		this.Pattern = pattern.toLowerCase();
	else
		this.Pattern = pattern ;
}
KmpMatch.prototype = {
	"FeedCharacter" : function( c )
	{
		if ( this._IgnoreCase )
			c = c.toLowerCase();

		while ( true )
		{
			if ( c == this.Pattern.charAt( this._State ) )
			{
				this._State++ ;
				if ( this._State == this.Pattern.length )
				{
					// found a match, start over, don't care about partial matches involving the current match
					this._State = 0;
					return KMP_MATCHED;
				}
				return KMP_ADVANCED ;
			}
			else if ( this._State == 0 )
				return KMP_NOMATCH;
			else
				this._State = this._Overlap[ this._State ];
		}

		return null ;
	},
	"Reset" : function()
	{
		this._State = 0 ;
	}
};

function _Fi


ae
	3,// EVEX_Vgetmantph_xmm_k1z_xmmm128b16_imm8
	3,// EVEX_Vgetmantph_ymm_k1z_ymmm256b16_imm8
	3,// EVEX_Vgetmantph_zmm_k1z_zmmm512b16_imm8_sae
	4,// EVEX_Vgetmantsh_xmm_k1z_xmm_xmmm16_imm8_sae
	3,// EVEX_Vmaxph_xmm_k1z_xmm_xmmm128b16
	3,// EVEX_Vmaxph_ymm_k1z_ymm_ymmm256b16
	3,// EVEX_Vmaxph_zmm_k1z_zmm_zmmm512b16_sae
	3,// EVEX_Vmaxsh_xmm_k1z_xmm_xmmm16_sae
	3,// EVEX_Vminph_xmm_k1z_xmm_xmmm128b16
	3,// EVEX_Vminph_ymm_k1z_ymm_ymmm256b16
	3,// EVEX_Vminph_zmm_k1z_zmm_zmmm512b16_sae
	3,// EVEX_Vminsh_xmm_k1z_xmm_xmmm16_sae
	2,// EVEX_Vmovsh_xmm_k1z_m16
	2,// EVEX_Vmovsh_m16_k1_xmm
	3,// EVEX_Vmovsh_xmm_k1z_xmm_xmm
	3,// EVEX_Vmovsh_xmm_k1z_xmm_xmm_MAP5_11
	2,// EVEX_Vmovw_xmm_r32m16
	2,// EVEX_Vmovw_xmm_r64m16
	2,// EVEX_Vmovw_r32m16_xmm
	2,// EVEX_Vmovw_r64m16_xmm
	3,// EVEX_Vmulph_xmm_k1z_xmm_xmmm128b16
	3,// EVEX_Vmulph_ymm_k1z_ymm_ymmm256b16
	3,// EVEX_Vmulph_zmm_k1z_zmm_zmmm512b16_er
	3,// EVEX_Vmulsh_xmm_k1z_xmm_xmmm16_er
	2,// EVEX_Vrcpph_xmm_k1z_xmmm128b16
	2,// EVEX_Vrcpph_ymm_k1z_ymmm256b16
	2,// EVEX_Vrcpph_zmm_k1z_zmmm512b16
	3,// EVEX_Vrcpsh_xmm_k1z_xmm_xmmm16
	3,// EVEX_Vreduceph_xmm_k1z_xmmm128b16_imm8
	3,// EVEX_Vreduceph_ymm_k1z_ymmm256b16_imm8
	3,// EVEX_Vreduceph_zmm_k1z_zmmm512b16_imm8_sae
	4,// EVEX_Vreducesh_xmm_k1z_xmm_xmmm16_imm8_sae
	3,// EVEX_Vrndscaleph_xmm_k1z_xmmm128b16_imm8
	3,// EVEX_Vrndscaleph_ymm_k1z_ymmm256b16_imm8
	3,// EVEX_Vrndscaleph_zmm_k1z_zmmm512b16_imm8_sae
	4,// EVEX_Vrndscalesh_xmm_k1z_xmm_xmmm16_imm8_sae
	2,// EVEX_Vrsqrtph_xmm_k1z_xmmm128b16
	2,// EVEX_Vrsqrtph_ymm_k1z_ymmm256b16
	2,// EVEX_Vrsqrtph_zmm_k1z_zmmm512b16
	3,// EVEX_Vrsqrtsh_xmm_k1z_xmm_xmmm16
	3,// EVEX_Vscalefph_xmm_k1z_xmm_xmmm128b16
	3,// EVEX_Vscalefph_ymm_k1z_ymm_ymmm256b16
	3,// EVEX_Vscalefph_zmm_k1z_zmm_zmmm512b16_er
	3,// EVEX_Vscalefsh_xmm_k1z_xmm_xmmm16_er
	2,// EVEX_Vsqrtph_xmm_k1z_xmmm128b16
	2,// EVEX_Vsqrtph_ymm_k1z_ymmm256b16
	2,// EVEX_Vsqrtph_zmm_k1z_zmmm512b16_er
	3,// EVEX_Vsqrtsh_xmm_k1z_xmm_xmmm16_er
	3,// EVEX_Vsubph_xmm_k1z_xmm_xmmm128b16
	3,// EVEX_Vsubph_ymm_k1z_ymm_ymmm256b16
	3,// EVEX_Vsubph_zmm_k1z_zmm_zmmm512b16_er
	3,// EVEX_Vsubsh_xmm_k1z_xmm_xmmm16_er
	2,// EVEX_Vucomish_xmm_xmmm16_sae
	0,// Rdudbg
	0,// Wrudbg
];
use std


ra.ISparseMatrix`1.ElementCount*">

ElementCount

Gets the number of elements in the matrix.

Declaration

int ElementCount { get; }

Property Value

        Type
        Description

        int

The element count.

Methods

FindDiagonalElement(int)

Finds the ISparseMatrixElement<T> on the diagonal.

Declaration

ISparseMatrixElement<T> FindDiagonalElement(int index)

Parameters

        Type
        Name
        Description

        int
        index

The index.

Returns

        Type
        Description

        ISparseMatrixElement<T>

The matrix element if it exists; otherwise null.

Exceptions


	generate_mysql_servers_table(&reader_hostgroup);
						generate_mysql_servers_table(&offline_hostgroup);
					}
				}
				delete resultset2;
				resultset2=NULL;
			}
			wrunlock();
			GloAdmin->mysql_servers_wrunlock();
			free(query);
		}
	}
	if (resultset) {
		delete resultset;
		resultset=NULL;
	}
}

/**
 * @brief Set the server specified by the supplied 'hostname:port' and hostgroup as 'writer'.
 * @details Tries to find the server as an already present 'writer' in the desired hostgroup, in case of not
 *  finding it:
 *    1. Move the server to target writer, preserving status if required.
 *    2. Deletes the server from other hostgroups in the cluster (determined by 'writer_hostgroup').
 *    3. If 'writer_is_also_reader', place the server also in the 'reader_hostgroup'.
 *    4. Converge the current configuration and rebuild the hostgroups.
 *
 *  If the server is already found, no action should be taken, and no reconfiguration triggered.
 *
 *  FOUND_AS_SHUNNED: If writer is found as SHUNNED is considered as a found writer, since we don't take
 *  reconfiguration actions based on SHUNNED state.
 *
 *  FOUND_AS_BACKUP_WRITER: If server is found in the 'backup_writer_hostgroup' is because the server has been
 *  previously considered as a writer, and due to an exceeding number of writers, the server
 *  ended in the 'backup_writer_hostgroup'. If the server is to be removed from this hostgroup
 *  and placed in other one, is something that should be done when converging to the final state
 *  after other actions 'set_offline|set_read_only' (via 'converge_group_replication_config'),
 *  otherwise, we will continously trying to place the already WRITER server as WRITER and
 *  constantly retriggering a servers reconfiguration everytime the available number of writers
 *  exceeds 'max_writers'.
 *
 *  PRESERVE-OFFLINE_SOFT: When server is not found as writer, but is found as 'OFFLINE_SOFT' this state is
 *  present when setting this server in the 'writer_hostgroup'.
 *
 * @param _hostname Hostname of the target server to be set as writer.
 * @param _port Port of the target server to be set as writer.
 * @param _writer_hostgroup 'writer_hostgroup' of the cluster in which server is going to be placed as writer.
 */
void MySQL_HostGroups_Manager::update_group_replication_set_writer(char *_hostname, int _port, int _writer_hostgroup) {
	int cols=0;
	int affected_rows=0;
	SQLite3_result *resultset=NULL;
	char *query=NULL;
	char *q=NULL;
	char *error=NULL;
	q=(char *)"SELECT hostgroup_id, status FROM mysql_servers JOIN mysql_group_replication_hostgroups ON hostgroup_id=writer_hostgroup OR hostgroup_id=reader_hostgroup OR hostgroup_id=backup_writer_hostgroup OR hostgroup_id=offline_hostgroup WHERE hostname='%s' AND port=%d AND status<>3";
	query=(char *)malloc(strlen(q)+strlen(_hostname)+32);
	sprintf(query,q,_hostname,_port);
  mydb->execute_statement(query, &error, &cols , &affected_rows , &resultset);
	if (error) {
		free(error);
		error=NULL;
	}
	free(query);

	int writer_is_also_reader=0;
	bool found_writer=false;
	bool found_reader=fa


# -*- coding=utf-8 -*-

import tensorflow as tf

from recognizer.models.crnn import densenet_crnn_time

K = tf.keras.backend
Lambda = tf.keras.layers.Lambda
Input = tf.keras.layers.Input

def ctc_lambda_func(args):
    prediction, label, input_length, label_length = args
    return K.ctc_batch_cost(label, prediction, input_length, label_length)

def crnn_model_based_on_densenet_crnn_time_softmax_activate(initial_learning_rate=0.0005):
    shape = (32, 280, 3)
    inputs = tf.keras.layers.Input(shape=shape, name='input_data')
    output = densenet_crnn_time(inputs=inputs, activation='softmax')
    model_body = tf.keras.models.Model(inputs, output)
    model_body.summary()

    label = Input(name='label', shape=[None], dtype='float32')
    input_length = Input(name='input_length', shape=[1], dtype='int64')
    label_length = Input(name='label_length', shape=[1], dtype='int64')

    loss_out = Lambda(ctc_lambda_func, output_shape=(1,), name='ctc')([output, label, input_length, label_length])

    model = tf.keras.models.Model(inputs=[inputs, label, input_length, label_length], outputs=loss_out)
    model.compile(loss={'ctc': lambda y_true, prediction: prediction},
                  optimizer=tf.keras.optimizers.Adam(initial_learning_rate), metrics=['accuracy'])
    return model_body, model


rgc, argv, envp and jumps to main.

.set noreorder

__start:
_start:
	bal     2f
	move    $fp, $0         /* delay slot */
1:
	.gpdword 1b
	.gpdword main
2:
	ld      $gp, 0($ra)
	dsubu   $gp, $ra, $gp   /* origin */
	ld      $t9, 8($ra)
	daddu   $t9, $t9, $gp   /* actual address of main */

	move    $ra, $zero

	ld      $a0, 0($sp)
	daddiu  $a1, $sp, 8     /* argv = sp + 8 */

	jalr    $t9
	nop                     /* delay slot */

	move    $a0, $v0        /* main return is _exit's first arg */
_exit:
	li      $v0, NR_exit
	syscall

.set reorder

.size _exit,.-_exit
.size _start,_exit-_start

.type _start,function
.type _exit,function

.section .note.GNU-stack,"",%progbits


.demilich.metastone.game.spells.desc.filter.ComparisonOperation;
import net.demilich.metastone.game.spells.desc.valueprovider.AttributeValueProvider;
import net.demilich.metastone.game.cards.Attribute;

/**
 * {@code true} when the {@code target} or {@link ConditionArg#TARGET} has an attribute {@link ConditionArg#ATTRIBUTE}
 * that evaluates to {@code true} with the {@link ConditionArg#OPERATION}.
 *

 * Only supports single targets.
 *

 * Uses the {@link ComparisonOperation#HAS} by default, or compares with the {@link ConditionArg#VALUE}.
 */
public class AttributeCondition extends Condition {

	public AttributeCondition(ConditionDesc desc) {
		super(desc);
	}

	@Override
	protected boolean isFulfilled(GameContext context, Player player, ConditionDesc desc, Entity source, Entity target) {
		var attribute = (Attribute) desc.get(ConditionArg.ATTRIBUTE);
		var operation = (ComparisonOperation) desc.get(ConditionArg.OPERATION);
		if (operation == null || operation == ComparisonOperation.HAS) {
			return target.hasAttribute(attribute);
		}

		var targetValue = desc.getValue(ConditionArg.VALUE, context, player, target, source, 0);
		var actualValue = AttributeValueProvider.provideValueForAttribute(context, attribute, target);

		return SpellUtils.evaluateOperation(operation, actualValue, targetValue);
	}

	@Override
	protected boolean singleTargetOnly() {
		return true;
	}
}
package net.demilich.metastone.game.decks.validation;

import net.demilich.metastone.game.cards.Card;
import com.hiddenswitch.spellsource.rpc.Spellsource.RarityMessage.Rarity;
import net.demilich.metastone.game.decks.GameDeck;
import net.demilich.metastone.game.logic.GameLogic;

/**
 * A deck validator of standard deck rules.
 *

 * It limits the number of duplicates of legendaries to 1, duplicates of other cards to 2.
 *

 * It requires exactly {@link GameLogic#DECK_SIZE} cards.
 *

 * It currently permits cards of any class regardless of the hero class of the given deck.
 *

 * The multiplayer Spellsource code contains different logic for validating decks.
 */
public final class DefaultDeckValidator implements DeckValidator {

	@Override
	public boolean canAddCardToDeck(Card card, GameDeck deck) {
		if (deck.getCards().getCount() > GameLogic.DECK_SIZE) {
			return false;
		}
		int cardInDeckCount = deck.containsHowMany(card);
		return card.getRarity() == Rarity.LEGENDARY ? cardInDeckCount < 1 : cardInDeckCount < 2;
	}

}
package net.demilich.metastone.game.cards.dynamicdescription;

import net.demilich.metastone.game.cards.desc.DescDeserializer;
import net.demilich.metastone.game.cards.desc.ParseValueType;

/**
 * A deserializer of dynamic descriptions.
 */
public class DynamicDescriptionDeserializer extends DescDeserializer<DynamicDescriptionDesc, DynamicDescriptionArg, DynamicDescription> {

	public DynamicDescriptionDeserializer() {
		super(DynamicDescriptionDesc.class);
	}

	protected DynamicDescriptionDeserializer(Class<? extends DynamicDescriptionDesc> vc) {
		super(vc);
	}

	@Override
	protected DynamicDescriptionDesc createDescInstance() {
		return new DynamicDescriptionDesc();
	}

	@Override
	public void init(SerializationContext ctx) {
		ctx.add(DynamicDescriptionArg.CONDITION, ParseValueType.CONDITION);
		ctx.add(DynamicDescriptionArg.V


                      {{- cond (eq .Site.Params.titlecase true) (.Title | title | markdownify) (.Title | markdownify) -}}

                              {{ with .Params.tldr }}{{ . | markdownify }}{{ else }}{{ (printf "%s
%s" (.Params.description | markdownify) .Summary) }}{{ end }}

  {{ end }}

{{ end }}

{{ define "pagination" }}

{{ end }}<!DOCTYPE html>

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    <meta name="google" content="notranslate">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>PDF.js viewer</title>

    <link rel="stylesheet" href="viewer.css">

<link rel="resource" type="application/l10n" href="locale/locale.properties">

            <button id="viewThumbnail" class="toolbarButton toggled" title="Show Thumbnails" tabindex="2" data-l10n-id="thumbs">
               Thumbnails
            </button>
            <button id="viewOutline" class="toolbarButton" title="Show Document Outline (double-click to expand/collapse all items)" tabindex="3" data-l10n-id="document_outline">
               Document Outline
            </button>
            <button id="viewAttachments" class="toolbarButton" title="Show Attachments" tabindex="4" data-l10n-id="attachments">
               Attachments
            </button>

          <div id="fi


"
		PreferredCardProtocol.T1 -> "T=1"
		PreferredCardProtocol.RAW -> throw IllegalArgumentException("RAW mode is not supported")
		PreferredCardProtocol.ANY -> "*"
	}

private suspend inline fun waitForCard(crossinline waitFun: suspend () -> Boolean) =
	coroutineScope {
		while (true) {
			if (!isActive) {
				// job has been cancelled, stop loop
				throw CancellationException("Waiting for a card event has been cancelled.")
			}
			if (waitFun()) {
				// change detected
				break
			}
		}
	}
package org.openecard.sal.iface

sealed class SalException(
	msg: String,
	cause: Throwable?,
) : Exception(msg, cause)

class InternalSystemError(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "An internal consistency check failed.", cause)

class NotInitialized(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "The underlying stack is not initialized.", cause)

class NoService(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "The underlying stack is not available.", cause)

class DeviceUnavailable(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "The requested device is not known or unavailable.", cause)

class RemovedDevice(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "The device has been removed, so further communication is not possible.", cause)

class DeviceUnsupported(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "The requested device is not supported by the SAL.", cause)

class Timeout(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "The call timed out.", cause)

class Cancelled(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "The call has been cancelled.", cause)

class SharingViolation(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "The device cannot be accessed because of other connections outstanding.", cause)

class UnsupportedFeature(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "The device does not support the requested feature.", cause)

class MissingAuthentication(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "Authentication missing in order to access the requested entity.", cause)

class SecureMessagingException(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "Error in secure messaging processing.", cause)

class AclUnfulfillable(
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: "Acl can not be fulfilled.", cause)

class PasswordError(
	type: PasswordErrorType,
	msg: String? = null,
	cause: Throwable? = null,
) : SalException(msg ?: type.msg, cause) {
	enum class PasswordErrorType(
		val msg: String,
	) {
		TOO_LONG("Provided password is too long"),
		TOO_SHORT("Provided password is too short"),
		INVALID_CHARACTERS("Provided password contains characters which are not allowed in this password"),
	}
}
package org.openecard.sal.sc.recognition

impo


   .Should()
        .BeSuccess(GetExpectedTokenResponse());

    [Fact]
    public void ShouldDeserializeGetSwapDate() => this.helper.Serializer
        .DeserializeObject<GetSwapDateResponse>(this.helper.GetResponseJson())
        .Should()
        .BeSuccess(GetExpectedResponse());

    [Fact]
    public void ShouldSerialize() =>
        GetSwapDateRequest.Parse("346661113334")
            .GetStringContent()
            .Should()
            .BeSuccess(this.helper.GetRequestJson());

    private static AuthorizeResponse GetExpectedAuthorizeResponse() => new AuthorizeResponse("123456789", 120, 2);

    private static GetTokenResponse GetExpectedTokenResponse() => new GetTokenResponse("ABCDEFG", "Bearer", 3600);

    private static GetSwapDateResponse GetExpectedResponse() =>
        new GetSwapDateResponse(DateTimeOffset.Parse("2019-08-24T14:15:22Z"));
}


isingedge, bool fallingedge, bool event,
                        xcpt_t func)
{
  xcpt_t oldhandler;

  /* Get the previous GPIO IRQ handler; Save the new IRQ handler. */

  oldhandler          = stm32_exti_callback;
  stm32_exti_callback = func;

  /* Install external interrupt handlers (if not already attached) */

  if (func)
    {
      irq_attach(STM32_IRQ_RTCALRM, stm32_exti_alarm_isr);
      up_enable_irq(STM32_IRQ_RTCALRM);
    }
  else
    {
      up_disable_irq(STM32_IRQ_RTCALRM);
    }

  /* Configure rising/falling edges */

  modifyreg32(STM32_EXTI_RTSR,
              risingedge ? 0 : EXTI_RTC_ALARM,
              risingedge ? EXTI_RTC_ALARM : 0);
  modifyreg32(STM32_EXTI_FTSR,
              fallingedge ? 0 : EXTI_RTC_ALARM,
              fallingedge ? EXTI_RTC_ALARM : 0);

  /* Enable Events and Interrupts */

  modifyreg32(STM32_EXTI_EMR,
              event ? 0 : EXTI_RTC_ALARM,
              event ? EXTI_RTC_ALARM : 0);
  modifyreg32(STM32_EXTI_IMR,
              func ? 0 : EXTI_RTC_ALARM,
              func ? EXTI_RTC_ALARM : 0);

  /* Return the old IRQ handler */

  return oldhandler;
}


widget {
    height: 100%;
}

#pages .page.type_text .group.widget {
    margin: 0.2em;
}

/* custom flavours */
.flavour_red:not(.group) .ui-slider .ui-slider-range {
    background-color: #FF0000;
}
.flavour_green:not(.group) .ui-slider .ui-slider-range {
    background-color: #00FF00;
}
.flavour_blue:not(.group) .ui-slider .ui-slider-range {
    background-color: #0000FF;
}

/* grid layout test */
.page.type_text .clearfix:not(.widget):not(.group) {
    display: grid;
    grid-template-columns: 8.33% 8.33% 8.33% 8.33% 8.33% 8.33% 8.33% 8.33% 8.33% 8.33% 8.33% 8.33%;
    grid-auto-rows: max-content;
    align-items: flex-start;
    margin-right: -1px;
    margin-bottom: -1px;
}
.page.type_text .custom_weather-forecast .clearfix:not(.widget):not(.group) {
    display: block !important;
    grid-template-columns: unset !important;
    grid-auto-rows: unset !important;
    align-items: unset !important;
    margin-right: unset !important;
    margin-bottom: unset !important;
}
ul.detailed li.night {
    display: inline-block !important;
}

.page.type_text .clearfix.custom_weather-forecast .widget_container.jowm .custom_weather-forecast {
    margin: 0 .5rem;
}
.page.type_text .widget_container.jowm {
    padding: 0;
}
.page.type_text .widget_container.jowm .separationLine {
    margin: 16px 0;
}

.page.type_text > .clearfix > .widget_container[data-type="navbar"] {
    display: none;
}

.page.type_text > .clearfix .widget_container:not(.jowm) {
    float: none;
    width: auto !important;
}

.page.type_text > .clearfix .widget_container.width-100 {
    grid-column-end: span 12;
}

.page.type_text > .clearfix .widget_container.width-75 {
    grid-column-end: span 9;
}

.page.type_text > .clearfix .widget_container.width-50 {
    grid-column-end: span 6;
}

.page.type_text > .clearfix .widget_container.width-25 {
    grid-column-end: span 3;
}

.page.type_text > .clearfix .widget_container.width-16 {
    grid-column-end: span 2;
}

/* groups */
.page.type_text > .clearfix .widget_container .group > .clearfix > h2 {
    grid-column-start: 1;
    grid-column-end: span 12;
}

.page.type_2d .widget_container, .page.type_2d .widget_container .group:not(.widget) {
    position: relative;
}
/*
 * @copyright   Copyright (C) 2010-2024 Combodo SAS
 * @license     http://opensource.org/licenses/AGPL-3.0
 */

$ibo-breadcrumbs--margin-right: $ibo-spacing-700 !default;

$ibo-breadcrumbs--item--text-color: $ibo-color-grey-800 !default;

$ibo-breadcrumbs--item-icon--margin-x: $ibo-spacing-300 !default;
$ibo-breadcrumbs--item-icon--max-width: 16px !default;
$ibo-breadcrumbs--ite


','SourceHanSerifCN';
  text-align: center;
  min-width: 10rem;
  font-weight: bold;
  color: rgb(181,54,41);
}

table td {
  min-width: 32px;
}

.md-table-resize-popover {
  width: auto !important;
}

/* Quote */
blockquote {
  display: block;
  font-size: 12pt;
  overflow: auto;
  border-left: 5px solid rgb(181,54,41);
  padding: 15px 30px 15px 20px;
  margin-bottom: 20px;
  margin-top: 20px;
  background: rgb(246, 248, 250);
  box-shadow: 4px 4px 5px #c5c0c0;
  border-radius:4px 15px 15px 4px;
  font-family: 'Cantarell','SourceHanSerifCN';
}

/* 行内代码 */
code {
  font-family: "JetBrainsMono",'SourceHanSerifCN';
}

h1 code, h2 code, h3 code, h4 code, h5 code, h6 code,
p code,
li code {
  color: rgb(181,54,41);
  background-color: #fefefe;
  font-family: "JetBrainsMono",'SourceHanSerifCN';
  font-weight: 900;
  text-align: justify;
  vertical-align: baseline;
  padding: 2px;
  background: rgb(246, 248, 250);
  border-radius: 14px;
  box-shadow: 1px 1px 5px #c8d3df;
}

/* 代码块样式 */
/* code fences */
/* mac风格样式 */
.md-fences:after {
  content: "";
  position: absolute;
  left: 11px;
  top: 5px;
  width: 12px;
  height: 12px;
  background-color: #ff374b;
  border-radius: 6px;
  z-index: 999999;
  box-shadow: 20px 0 #ffc600, 40px 0 #00e03d;
}

.CodeMirror.cm-s-inner {
  margin-top: 15px;
  /* background-color: white;  */
  /*  这个背景颜色修改了没有用*/
  border-radius: 3px;
}

/* 去除默认代码块后的背景，让颜色和书写背景一致 */

.cm-s-inner.CodeMirror {
  padding: 1.5rem .8rem;
  color: #4f5467;
  font-family: 'JetBrainsMono';
  font-weight: 900;
  font-size: 1em;
  background-color: #f5f6f7;
  /* 这个背景颜色并非指向代码块后面的背景颜色 */
  /* border: 1px solid #eef2f5;*/
  line-height: 1.6rem;
  border-radius: 10px;
}

/* 去除数字后的线 */
.cm-s-inner .CodeMirror-gutters {
  border: none;
}

/*  Code Block - Color Scheme */

 .cm-s-inner .cm-keyword {
  color: rgb(181,54,41) !important;
}

.cm-s-inner .cm-operator {
  color: rgb(177, 103, 95) !important;
}

.cm-s-inner .cm-variable,
.cm-s-inner .cm-builtin,
.cm-s-inner .cm-header,
.cm-s-inner .cm-tag,
.cm-s-inner .cm-property,
.cm-s-inner .cm-quote {
  color: #b9218e !important;
}

.cm-s-inner .cm-variable-2 {
  color: #7aadad !important;
}

.cm-s-inner .cm-variable-3,
.cm-s-inner .cm-type,
.cm-s-inner .cm-atom {
  color: rgb(234, 130, 128) !important;
}

.cm-s-inner .cm-number {
  color: rgb(1


            height: 100%;
            max-height: calc(80vh - 2.5rem);
        }
    }
}

.container>.sticky-top-nav, .container-fluid>.sticky-top-nav {
    margin-left: calc(var(--bs-gutter-x) * -0.5);
    margin-right: calc(var(--bs-gutter-x) * -0.5);
}

// Moves item content out from under navbar but container stays under navbar to provide background.
// This is used for transparent sticky or fixed navbars.
.tuck-under-navbar {
    margin-top: -$navbar-height;
    padding-top: $navbar-height;
}

// Prevents navbar from hidding under navbar.
// This is used for fully opaque sticky or fixed navbars.
.clear-from-under-navbar {
    margin-top: calc($navbar-height + 1px );
}

.web-app-left-nav-sized-container {
    padding: 0px;
    margin: 0px;

    @include media-breakpoint-up(lg) {
        width: $left-nav-w;
    }
}

.webapp-content-max-width-container {
    max-width: $webapp-content-max-width;
    margin: 0px 20px;
    min-height: calc(100vh - $navbar-height - $breadcrumb-height - 1px);

    @include media-breakpoint-up(md) {
        margin: 0px auto;
    }
  }
//
// Default SASS Variable Overrides
//

// Neutral Scale
$gray-100: #FFFFFF;
$gray-200: #DEE0E7;
$gray-300: #ABACB0;
$gray-400: #777A81;
$gray-500: #51545B;
$gray-600: #2F3033;
$gray-700: #212224;
$gray-800: #17181A;
$gray-900: #000000;

// Violet Scale
$violet-shade-100: #A105FF;

// Neon Scale
$neon-tint-100: #5162FF;
$neon-tint-200: #6271FF;
$neon-tint-300: #7381FF;
$neon-tint-400: #8591FF;
$neon-tint-500: #96A0FF;
$neon-tint-600: #A8B0FF;
$neon-tint-700: #B9C0FF;
$neon-tint-800: #CACFFF;
$neon-tint-900: #DCDFFF;
$neon-tint-1000: #EDEFFF;

$neon-shade-100: #5162FF;
$neon-shade-200: #4858E5;
$neon-shade-300: #404ECC;
$neon-shade-400: #3844B2;
$neon-shade-500: #303A99;
$neon-shade-600: #28317F;
$neon-shade-700: #202766;
$neon-shade-800: #181D4C;
$neon-shade-900: #101333;
$neon-shade-1000: #080919;

// Teal Scale
$teal-tint-100: #00E0FF;
$teal-tint-200: #00c9e5;
$teal-tint


using System;
using System.Text;
using Server.Gumps;
using Server.Network;

namespace Server.Items
{
	public class HairDye : Item
	{
		public override int LabelNumber{ get{ return 1041060; } } // Hair Dye

		[Constructable]
		public HairDye() : base( 0xEFF )
		{
			Weight = 1.0;
		}

		public HairDye( Serial serial ) : base( serial )
		{
		}

		public override void Serialize( GenericWriter writer )
		{
			base.Serialize( writer );

			writer.Write( (int) 0 ); // version
		}

		public override void Deserialize( GenericReader reader )
		{
			base.Deserialize( reader );

			int version = reader.ReadInt();
		}

		public override void OnDoubleClick( Mobile from )
		{
			if ( from.InRange( this.GetWorldLocation(), 1 ) )
			{
				from.CloseGump( typeof( HairDyeGump ) );
				from.SendGump( new HairDyeGump( this ) );
			}
			else
			{
				from.LocalOverheadMessage( MessageType.Regular, 906, 1019045 ); // I can't reach that.
			}
		}
	}

	public class HairDyeGump : Gump
	{
		private HairDye m_HairDye;

		private class HairDyeEntry
		{
			private string m_Name;
			private int m_HueStart;
			private int m_HueCount;

			public string Name
			{
				get
				{
					return m_Name;
				}
			}

			public int HueStart
			{
				get
				{
					return m_HueStart;
				}
			}

			public int HueCount
			{
				get
				{
					return m_HueCount;
				}
			}

			public HairDyeEntry( string name, int hueStart, int hueCount )
			{
				m_Name = name;
				m_HueStart = hueStart;
				m_HueCount = hueCount;
			}
		}

		private static HairDyeEntry[] m_Entries = new HairDyeEntry[]
			{
				new HairDyeEntry( "*****", 1602, 26 ),
				new HairDyeEntry( "*****", 1628, 27 ),
				new HairDyeEntry( "*****", 1502, 32 ),
				new HairDyeEntry( "*****", 1302, 32 ),
				new HairDyeEntry( "*****", 1402, 32 ),
				new HairDyeEntry( "*****", 1202, 24 ),
				new HairDyeEntry( "*****", 2402, 29 ),
				new HairDyeEntry( "*****", 2213, 6 ),
				new HairDyeEntry( "*****", 1102, 8 ),
				new HairDyeEntry( "*****", 1110, 8 ),
				new HairDyeEntry( "*****", 1118, 16 ),
				new HairDyeEntry( "*****", 1134, 16 )
			};

		public HairDyeGump( HairDye dye ) : base( 50, 50 )
		{
			m_HairDye = dye;

			AddPage( 0 );


        priority: 0,
        flags: {protect: 1, mirror: 1},
        selfSwitch: true,
        secondary: null,
        target: "normal",
        type: "Psychic",
        contestType: "Clever",
    },
    "wingattack": {
        num: 17,
        accuracy: 100,
        basePower: 85,
        category: "Physical",
        shortDesc: "Has a 10% chance to lower the opponent's Speed by 1.",
        id: "wingattack",
        name: "Wing Attack",
        pp: 35,
        priority: 0,
        flags: {contact: 1, protect: 1, mirror: 1, distance: 1},
        secondary: {
            chance: 20,
            boosts: {
                spe: -1,
            },
        },
        target: "any",
        type: "Flying",
        contestType: "Cool",
    },
    "dragonrush": {
        num: 407,
        accuracy: 85,
        basePower: 100,
        category: "Physical",
        desc: "Has a 20% chance to flinch the target. Damage doubles and no accuracy check is done if the target has used Minimize while active.",
        shortDesc: "20% chance to flinch the target.",
        id: "dragonrush",
        name: "Dragon Rush",
        pp: 10,
        priority: 0,
        flags: {contact: 1, protect: 1, mirror: 1},
        secondary: {
            chance: 20,
            volatileStatus: 'flinch',
        },
        target: "normal",
        type: "Dragon",
        contestType: "Tough",
    },
    "spikecannon": {
        num: 131,
        accuracy: 100,
        basePower: 25,
        category: "Physical",
        desc: "Hits two to five times. Has a 1/3 chance to hit two or three times, and a 1/6 chance to hit four or five times. If one of the hits breaks the target's substitute, it will take damage for the remaining hits. If the user has the Skill Link Ability, this move will always hit five times.",
        shortDesc: "Hits 2-5 times in one turn.",
        id: "spikecannon",
        isNonstandard: "Past",
        name: "Spike Cannon",
        pp: 15,
        priority: 0,
        flags: {protect: 1, mirror: 1},
        multihit: [2, 5],
        secondary: null,
        target: "normal",
        type: "Steel",
        gmaxPower: 120,
        contestType: "Cool",
    },
    "sharpsteel": {
        accuracy: true,
        basePower: 0,
        category: "Status",
        shortDesc: "Hurts foes on switch-in. Factors Steel weakness.",
        id: "Sharp Steel",
        isViable: true,
        name: "Sharp Steel",
        pp: 20,
        priority: 0,
        flags: {reflectable: 1},
        sideCondition: 'sharpsteel',
        condition: {
            // this is a side condition
            onStart(side) {
                this.add('-sidestart', side, 'move: Sharp Steel');
            },
            onSwitchIn(pokemon) {
                if (pokemon.hasItem('heavydutyboots')) return;
                let typeMod = this.dex.clampIntRange(pokemon.runEffectiveness(this.dex.getActiveMove('sharpsteel')), -6, 6);
                this.damage(pokemon.maxhp * Math.pow(2, typeMod) / 8);
            },
        },
        secondary: null,
        target: "foeSide",
        type: "Steel",
        zMoveBoost: {def: 1},
        contestType: "Cool",
    },
    "oxidation": {
        accuracy: 100,
        basePower: 70


step_end

	.balign 4, 0
_0414:
	step 15, 1
	step_end

	.balign 4, 0
_041C:
	step 15, 2
	step_end

	.balign 4, 0
_0424:
	step 15, 3
	step_end

	.balign 4, 0
_042C:
	step 34, 1
	step_end

	.balign 4, 0
_0434:
	step 35, 1
	step_end

scr_seq_T26GYM0101_002:
	scrcmd_609
	lockall
	apply_movement obj_T26GYM0101_gsgirl1, _040C
	wait_movement
	get_player_coords VAR_TEMP_x4000, VAR_TEMP_x4001
	compare VAR_TEMP_x4000, 5
	goto_if_ne _046B
	apply_movement obj_T26GYM0101_gsgirl1, _04B8
	goto _048E

_046B:
	compare VAR_TEMP_x4000, 6
	goto_if_ne _0486
	apply_movement obj_T26GYM0101_gsgirl1, _04C0
	goto _048E

_0486:
	apply_movement obj_T26GYM0101_gsgirl1, _04C8
_048E:
	apply_movement obj_player, _0434
	wait_movement
	npc_msg msg_0606_T26GYM0101_00021
	wait_button_or_walk_away
	closemsg
	releaseall
	compare VAR_UNK_410E, 2
	goto_if_ne _04B4
	setvar VAR_UNK_410E, 3
_04B4:
	end

	.balign 4, 0
_04B8:
	step 14, 3
	step_end

	.balign 4, 0
_04C0:
	step 14, 2
	step_end

	.balign 4, 0
_04C8:
	step 14, 1
	step_end

scr_seq_T26GYM0101_003:
	play_se SEQ_SE_DP_SELECT
	lockall
	faceplayer
	check_badge BADGE_MINERAL, VAR_SPECIAL_RESULT
	compare VAR_SPECIAL_RESULT, 1
	goto_if_ne _04F4
	npc_msg msg_0606_T26GYM0101_00020
	goto _04F7

_04F4:
	npc_msg msg_0606_T26GYM0101_00019
_04F7:
	wait_button_or_walk_away
	closemsg
	releaseall
	compare VAR_UNK_410E, 1
	goto_if_ne _0510
	setvar VAR_UNK_410E, 2
_0510:
	end

scr_seq_T26GYM0101_004:
	play_se SEQ_SE_DP_SELECT
	lockall
	faceplayer
	check_badge BADGE_MINERAL, VAR_SPECIAL_RESULT
	compare VAR_SPECIAL_RESULT, 1
	goto_if_ne _0536
	npc_msg msg_0606_T26GYM0101_00022
	goto _0539

_0536:
	npc_msg msg_0606_T26GYM0101_00021
_0539:
	wait_button_or_walk_away
	closemsg
	releaseall
	compare VAR_UNK_410E, 2
	goto_if_ne _0552
	setvar VAR_UNK_410E, 3
_0552:
	end

scr_seq_T26GYM0101_005:
	play_se SEQ_SE_DP_SELECT
	lockall
	faceplayer
	check_badge BADGE_MINERAL, VAR_SPECIAL_RESULT
	compare VAR_SPECIAL_RESULT, 1
	goto_if_eq _0590
	compare VAR_UNK_410E, 0
	goto_if_ne _0585
	npc_msg msg_0606_T26GYM0101_00016


	if (!s_Il2CppMethodInitialized)
	{
		il2cpp_codegen_initialize_method (Array_IndexOf_m0F86629A6EFC0E9EF350A0D1D37EF582CDC48135_MetadataUsageId);
		s_Il2CppMethodInitialized = true;
	}
	int32_t V_0 = 0;
	ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* V_1 = NULL;
	int32_t V_2 = 0;
	int32_t V_3 = 0;
	int32_t V_4 = 0;
	RuntimeObject * V_5 = NULL;
	int32_t V_6 = 0;
	RuntimeObject * V_7 = NULL;
	{
		RuntimeArray * L_0 = ___array0;
		if (L_0)
		{
			goto IL_000e;
		}
	}
	{
		ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
		ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteral19EDC1210777BA4D45049C29280D9CC5E1064C25, /*hidden argument*/NULL);
		IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, Array_IndexOf_m0F86629A6EFC0E9EF350A0D1D37EF582CDC48135_RuntimeMethod_var);
	}

IL_000e:
	{
		RuntimeArray * L_2 = ___array0;
		NullCheck(L_2);
		int32_t L_3 = Array_get_Rank_m38145B59D67D75F9896A3F8CDA9B966641AE99E1(L_2, /*hidden argument*/NULL);
		if ((((int32_t)L_3) == ((int32_t)1)))
		{
			goto IL_0022;
		}
	}
	{
		RankException_t85F27ECAFB95F8FC0E72E5EA676169A3CE9B4B6F * L_4 = (RankException_t85F27ECAFB95F8FC0E72E5EA676169A3CE9B4B6F *)il2cpp_codegen_object_new(RankException_t85F27ECAFB95F8FC0E72E5EA676169A3CE9B4B6F_il2cpp_TypeInfo_var);
		RankException__ctor_m5C185B91AFCA252366D882B15B65C984BF02004D(L_4, _stringLiteral8CC78C31A65D0239AD6A66D0065C5B8B3AB1F69D, /*hidden argument*/NULL);
		IL2CPP_RAISE_MANAGED_EXCEPTION(L_4, Array_IndexOf_m0F86629A6EFC0E9EF350A0D1D37EF582CDC48135_RuntimeMethod_var);
	}

IL_0022:
	{
		RuntimeArray * L_5 = ___array0;
		NullCheck(L_5);
		int32_t L_6 = Array_GetLowerBound_mDCFD284D55CFFA1DD8825D7FCF86A85EFB71FD1B(L_5, 0, /*hidden argument*/NULL);
		V_0 = L_6;
		int32_t L_7 = ___startIndex2;
		int32_t L_8 = V


x1c,0xf0,0x1c]
vaddpd 485498096(%edx,%eax,4), %zmm2, %zmm2

// CHECK: vaddpd -485498096(%edx,%eax,4), %zmm2, %zmm2 {%k2}
// CHECK: encoding: [0x62,0xf1,0xed,0x4a,0x58,0x94,0x82,0x10,0xe3,0x0f,0xe3]
vaddpd -485498096(%edx,%eax,4), %zmm2, %zmm2 {%k2}

// CHECK: vaddpd 485498096(%edx,%eax,4), %zmm2, %zmm2 {%k2}
// CHECK: encoding: [0x62,0xf1,0xed,0x4a,0x58,0x94,0x82,0xf0,0x1c,0xf0,0x1c]
vaddpd 485498096(%edx,%eax,4), %zmm2, %zmm2 {%k2}

// CHECK: vaddpd -485498096(%edx,%eax,4), %zmm2, %zmm2 {%k2} {z}
// CHECK: encoding: [0x62,0xf1,0xed,0xca,0x58,0x94,0x82,0x10,0xe3,0x0f,0xe3]
vaddpd -485498096(%edx,%eax,4), %zmm2, %zmm2 {%k2} {z}

// CHECK: vaddpd 485498096(%edx,%eax,4), %zmm2, %zmm2 {%k2} {z}
// CHECK: encoding: [0x62,0xf1,0xed,0xca,0x58,0x94,0x82,0xf0,0x1c,0xf0,0x1c]
vaddpd 485498096(%edx,%eax,4), %zmm2, %zmm2 {%k2} {z}

// CHECK: vaddpd 485498096(%edx), %zmm2, %zmm2
// CHECK: encoding: [0x62,0xf1,0xed,0x48,0x58,0x92,0xf0,0x1c,0xf0,0x1c]
vaddpd 485498096(%edx), %zmm2, %zmm2

// CHECK: vaddpd 485498096(%edx), %zmm2, %zmm2 {%k2}
// CHECK: encoding: [0x62,0xf1,0xed,0x4a,0x58,0x92,0xf0,0x1c,0xf0,0x1c]
vaddpd 485498096(%edx), %zmm2, %zmm2 {%k2}

// CHECK: vaddpd 485498096(%edx), %zmm2, %zmm2 {%k2} {z}
// CHECK: encoding: [0x62,0xf1,0xed,0xca,0x58,0x92,0xf0,0x1c,0xf0,0x1c]
vaddpd 485498096(%edx), %zmm2, %zmm2 {%k2} {z}

// CHECK: vaddpd 485498096, %zmm2, %zmm2
// CHECK: encoding: [0x62,0xf1,0xed,0x48,0x58,0x15,0xf0,0x1c,0xf0,0x1c]
vaddpd 485498096, %zmm2, %zmm2

// CHECK: vaddpd 485498096, %zmm2, %zmm2 {%k2}
// CHECK: encoding: [0x62,0xf1,0xed,0x4a,0x58,0x15,0xf0,0x1c,0xf0,0x1c]
vaddpd 485498096, %z


NullPointerException
```

or

```
Have smaller server identifier, so dropping the connection
```

Try to restart the Zookeeper leader (by deleting that pod) and wait for it to come up again.

The root cause of this error is likely to be https://issues.apache.org/jira/browse/ZOOKEEPER-3988 which is fixed in Zookeeper 3.6.4 and 3.7.1/3. Upgrading to Confluent for Kubernetes 2.6.1 and Confluent Platform 7.4.1 is recommended.

### Check that Kafka is using the Zookeeper deployments

Look at the ZK nodes.

```
$ kubectl exec -it zookeeper-0 -n central -c zookeeper --context mrc-central -- bash

bash-4.4$ zookeeper-shell 127.0.0.1:2181

ls /mrc/brokers/ids
[0, 1, 10, 11, 20, 21]

# You should see 6 brokers ^
```# Security considerations for Red Hat Openshift

## Pod Security

CFK, by default, configures the Pod Security Context to run as non-root with a UID and GUID `1001`.

In Red Hat OpenShift, by default Security Context Constraint (SCC) does not allow a pod to run with the above security context.

You've got two options to align with the Security Context Constraint (SCC) needs on Red Hat OpenShift:

1) Recommended: Deploy with default SCC policy
2) Advanced: Deploy with a custom SCC policy

Before continuing with the scenario, ensure that you have set up the
[prerequisites](/README.md#prerequisites).

Set the tutorial directory for this tutorial under the directory you downloaded
the tutorial files:

```
export TUTORIAL_HOME=<Tutorial directory>/security/openshift-security
```

## Recommended: Install Confluent for Kubernetes using default SCC policy

Install Confluent for Kubernetes using the default SCC:

```
# Disable the custom pod security context, use the default context

helm upgrade --install confluent-operator confluentinc/confluent-for-kubernetes \
--set podSecurity.enabled=false --namespace confluent
```

In every Confluent component CustomResource, add `podSecurityContext`:

```
vi $TUTORIAL_HOME/confluent-platform-with-defaultSCC.yaml
...
spec:
  podTemplate:
    podSecurityContext: {} # Disable the custom pod security context, to use the default
...
```

Deploy Confluent Platform CRs with the `podSecurityContext`:

```
kubectl apply -f $TUTORIAL_HOME/confluent-platform-with-defaultSCC.yaml
```

## Advanced: Install Confluent for Kubernetes with custom SCC policy

In this advanced option, you can define a custom SCC policy and configure Confluent for Kubernetes
to use that. You'll follow these steps to do this:

1) Define a custom SCC policy
2) Associate the SCC policy to the service accounts used by Confluent for Kubernetes and Confluent Platform
3) Install Confluent for Kubernetes using the custom SCC

### 1) Define a custom SCC policy

Set a custom SCC in Red Hat OpenShift

```
## View the custom policy and the ID ranges allowed
vi $TUTORIAL_HOME/scc.yaml
...
fsGroup:
  type: MustRunAs
  ranges:
    # Configure allowed group ID to be between 1001 and 1005.
    - min: 1001
      max: 1005
...
runAsUser:
   # Configure allowed user ID to be between 1000 and 1005
  type: MustRunAsRange
  uidRangeMin: 1000
  uidRangeMax: 1005
...

## Set the SCC policy for the CFK Operator pod
oc apply -f $TUTORIAL_HOME/scc.yaml
```

### 2) Associate the SCC policy to the service accounts

Associate the SCC policy to the service account that runs CFK Operator:

```
## This is the format of t


chforward'))
      feed('n')
      eq({ 1, 5 }, api.nvim_win_get_cursor(0))

      local screen = Screen.new(60, 3)
      eq(1, eval('v:hlsearch'))
      screen:expect {
        grid = [[
         {10:foo} {10:^foo} {10:foo}                                                |
        {1:~                                                           }|
                                                                    |
      ]],
      }
      exec_lua([[vim.v.hlsearch = 0]])
      eq(0, eval('v:hlsearch'))
      screen:expect {
        grid = [[
         foo ^foo foo                                                |
        {1:~                                                           }|
                                                                    |
      ]],
      }
      exec_lua([[vim.v.hlsearch = 1]])
      eq(1, eval('v:hlsearch'))
      screen:expect {
        grid = [[
         {10:foo} {10:^foo} {10:foo}                                                |
        {1:~                                                           }|
                                                                    |
      ]],
      }
    end)
  end)

  describe('options', function()
    describe('vim.bo', function()
      it('can get and set options', function()
        eq('', fn.luaeval 'vim.bo.filetype')
        exec_lua(function()
          _G.BUF = vim.api.nvim_create_buf(false, true)
          vim.api.nvim_set_option_value('filetype', 'markdown', {})
          vim.api.nvim_set_option_value('modifiable', false, { buf = _G.BUF })
        end)
        eq(false, fn.luaeval 'vim.bo.modified')
        eq('markdown', fn.luaeval 'vim.bo.filetype')
        eq(false, fn.luaeval 'vim.bo[BUF].modifiable')
        exec_lua(function()
          vim.bo.filetype = ''
          vim.bo[_G.BUF].modifiable = true
        end)
        eq('', fn.luaeval 'vim.bo.filetype')
        eq(true, fn.luaeval 'vim.bo[BUF].modifiable')
      end)

      it('errors', function()
        matches("Unknown option 'nosuchopt'$", pcall_err(exec_lua, 'return vim.bo.nosuchopt'))
        matches('Expected Lua string$', pcall_err(exec_lua, 'return vim.bo[0][0].autoread'))
        matches('Invalid buffer id: %-1$', pcall_err(exec_lua, 'return vim.bo[-1].filetype'))
      end)
    end)

    describe('vim.wo', function()
      it('can get and set options', function()
        exec_lua(function()
          vim.api.nvim_set_option_value('cole', 2, {})
          vim.cmd 'split'
          vim.api.nvim_set_option_value('cole', 2, {})
        end)
        eq(2, fn.luaeval 'vim.wo.cole')
        exec_lua(function()
          vim.wo.conceallevel = 0
        end)
        eq(0, fn.luaeval 'vim.wo.cole')
        eq(0, fn.luaeval 'vim.wo[0].cole')
        eq(0, fn.luaeval 'vim.wo[1001].cole')
        matches("Unknown option 'notanopt'$", pcall


公算是习呆呆的铁杆。所以习呆呆在7票中只能占2票。
　　而这一届的七个葫芦娃分别是：<q style="background-color:#DDD;">习近平、李克强、栗战书、汪洋、王沪宁、赵乐际、韩正</q>。虽然王公公出局了，但是多了“大内总管栗公公”和“吏部尚书赵公公”。（十九大后）赵公公将接替王公公掌管东厂，而栗公公（如果不出意外的话）将在明年（2018）两会上当选“全国人大委员长”。所以习呆呆在7票中【至少】占了3票。为啥说【至少】捏？因为“王沪宁”还不太确定。有说法认为“王沪宁也是习的铁杆”；还有的说法认为“王沪宁只是技术官僚（理论家），派系色彩不明显”。假设王沪宁这票也算上，呆呆派系能掌控4票（票数过半）。

◇更多的亲信【入局】

　　如今的裆中央政治局有25人，除了前面提及的7个常委，还有18人属于【非常委】的政治局委员。
　　关注朝廷时局的同学，大都只留意了“政治局常委”，而忽略了【不是常委】的这18个人。但这些人也很重要哦——因为这里面的某些人将成为下一届的【常委候选人】。
　　咱们来看看新一届政治局【非常委】的18人（以根据姓氏笔画排序）。对于习呆呆的铁杆，俺会在姓名边上标注。

丁薛祥（习呆呆核心幕僚，目前是大内副总管，有望接任大内总管）
王晨
刘鹤（习呆呆核心幕僚，60年代就读北京101中学时与习呆呆是【同班同学】）
许其亮
孙春兰
李希
李强（如今的江苏巡抚，“之江新军”骨干成员）
李鸿忠（如今的天津巡抚，依靠大力鼓吹“习


 < i; x++)
              text += `${preHeaders[x]}.`

            text += '1.'
          }

          menu.children(`:eq(${i})`).find('span.mce-text').text(text)
        }
      }

      // Disable
      else if (selectedElement.is('h1') && selectedElement.parents(SPECIAL_SECTION_SELECTOR)) {
        menu.children(':gt(10)').addClass('mce-disabled')
      }
    }
  },

  /**
   * Restore normal text in section toolbar and disable all
   */
  restoreSectionToolbar: function (menu) {

    let cnt = 1

    menu.children(':lt(6)').each(function () {
      let text = `${HEADING} `

      for (let i = 0; i < cnt; i++)
        text += `1.`

      $(this).find('span.mce-text').text(text)
      $(this).addClass('mce-disabled')

      cnt++
    })

    // Enable upgrade/downgrade last three menu items
    menu.children(':gt(10)').removeClass('mce-disabled')
  },

  manageDelete: function () {

    let range = tinymce.activeEditor.selection.getRng()
    let startNode = $(range.startContainer).parent()
    let endNode = $(range.endContainer).parent()
    let commonAncestorContainer = $(range.commonAncestorContainer)

    // Deepness is relative to the common ancestor container of the range startContainer and end
    let deepness = endNode.parent('section').parentsUntil(commonAncestorContainer).length + 1
    let currentElement = endNode
    let toMoveElements = []

    tinymce.activeEditor.undoManager.transact(function () {

      // Get and detach all next_end
      for (let i = 0; i <= deepness; i++) {
        currentElement.nextAll('section,p,figure').each(function () {
          toMoveElements.push($(this))

          $(this).detach()
        })
        currentElement = currentElement.parent()
      }

      // Execute delete
      tinymce.activeEditor.execCommand('delete')

      // Detach all next_begin
      startNode.nextAll().each(function () {
        $(this).detach()
      })

      // Append all next_end to startnode parent
      toMoveElements.forEach(function (element) {
        startNode.parent('section').append(element)
      })

      tinymce.triggerSave()

      // Refresh headings
      headingDimension()

      // Update references if needed
      updateReferences()

      updateIframeFromSavedContent()
    })
    return false
  }
}
//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluaXQuanMiLCJyYWplX2Jsb2Nrcy5qcyIsInJhamVfY3Jvc3NyZWYuanMiLCJyYWplX2ZpZ3VyZXMuanMiLCJyYWplX2lubGluZXMuanMiLCJyYWplX2xpc3RzLmpzIiwicmFqZV9tZXRhZGF0YS5qcyIsInJhamVfc2F2ZS5qcyIsInJhamVfc2VjdGlvbi5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO


nstance.toColumns(true);
    if (data.containsKey('ID')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['ID']!, _idMeta));
    }
    if (data.containsKey('ID_COMANDA_DETALHE')) {
      context.handle(
          _idComandaDetalheMeta,
          idComandaDetalhe.isAcceptableOrUnknown(
              data['ID_COMANDA_DETALHE']!, _idComandaDetalheMeta));
    }
    if (data.containsKey('ID_PRODUTO')) {
      context.handle(_idProdutoMeta,
          idProduto.isAcceptableOrUnknown(data['ID_PRODUTO']!, _idProdutoMeta));
    }
    if (data.containsKey('NOME_PRODUTO')) {
      context.handle(
          _nomeProdutoMeta,
          nomeProduto.isAcceptableOrUnknown(
              data['NOME_PRODUTO']!, _nomeProdutoMeta));
    }
    if (data.containsKey('QUANTIDADE')) {
      context.handle(
          _quantidadeMeta,
          quantidade.isAcceptableOrUnknown(
              data['QUANTIDADE']!, _quantidadeMeta));
    }
    if (data.containsKey('VALOR_UNITARIO')) {
      context.handle(
          _valorUnitarioMeta,
          valorUnitario.isAcceptableOrUnknown(
              data['VALOR_UNITARIO']!, _valorUnitarioMeta));
    }
    if (data.containsKey('VALOR_TOTAL')) {
      context.handle(
          _valorTotalMeta,
          valorTotal.isAcceptableOrUnknown(
              data['VALOR_TOTAL']!, _valorTotalMeta));
    }
    return context;
  }

  @override
  Set<GeneratedColumn> get $primaryKey => {id};
  @override
  ComandaDetalheComplemento map(Map<String, dynamic> data,
      {String? tablePrefix}) {
    return ComandaDetalheComplemento.fromData(data,
        prefix: tablePrefix != null ? '$tablePrefix.' : null);
  }

  @override
  $ComandaDetalheComplementosTable createAlias(String alias) {
    return $ComandaDetalheComplementosTable(attachedDatabase, alias);
  }
}

class ComandaObservacaoPadrao extends DataClass
    implements Insertable<ComandaObservacaoPadrao> {
  final int? id;
  final String? codigo;
  final String? descricao;
  ComandaObservacaoPadrao({this.id, this.codigo, this.descricao});
  factory ComandaObservacaoPadrao.fromData(Map<String, dynamic> data,
      {String? prefix}) {
    final effectivePrefix = prefix ?? '';
    return ComandaObservacaoPadrao(
      id: const IntType().mapFromDatabaseResponse(data['${effectivePrefix}ID']),
      codigo: const StringType()
          .mapFromDatabaseResponse(data['${effectivePrefix}CODIGO']),
      descricao: const StringType()
          .mapFromDatabaseResponse(data['${effectivePrefix}DESCRICAO']),
    );
  }
  @override
  Map<String, Expression> toColumns(bool nullToAbsent) {
    final map = <String, Expression>{};
    if (!nullToAbsent || id != null) {
      map['ID'] = Variable<int?>(id);
    }
    if (!nullToAbsent || codigo != null) {
      map['CODIGO'] = Variable<String?>(codigo);
    }
    if (!nullToAbsent || descricao != null) {
      map['DESCRICAO'] = Variable<String?>(descricao);
    }
    return map;
  }

  ComandaObservacaoPadraosCompanion toCompanion(bool nullToAbsent) {
    return ComandaObservacaoPadraosCompanion(
      id: id == null && nullToAbsent ? const Value.absent() : Value(id),
      codigo:
          codigo == null && nullToAbsent ? const Value.absent() : Value(codigo),
      descricao: descric


[5])
@pytest.mark.parametrize("tp_size", [1])
def test_models(
    aphrodite_runner: type[AphroditeRunner],
    example_prompts: list[str],
    model: GGUFTestConfig,
    dtype: str,
    max_tokens: int,
    num_logprobs: int,
    tp_size: int,
) -> None:
    check_model_outputs(aphrodite_runner, example_prompts, model, dtype, max_tokens,
                        num_logprobs, tp_size)

@pytest.mark.skipif(not is_quant_method_supported("gguf"),
                    reason="gguf is not supported on this GPU type.")
@pytest.mark.parametrize("model", [LLAMA_CONFIG])
@pytest.mark.parametrize("dtype", ["half"])
@pytest.mark.parametrize("max_tokens", [8])
@pytest.mark.parametrize("num_logprobs", [5])
@pytest.mark.parametrize("tp_size", [2])
@multi_gpu_test(num_gpus=2)
def test_distributed(
    aphrodite_runner: type[AphroditeRunner],
    example_prompts: list[str],
    model: GGUFTestConfig,
    dtype: str,
    max_tokens: int,
    num_logprobs: int,
    tp_size: int,
) -> None:
    check_model_outputs(aphrodite_runner, example_prompts, model, dtype, max_tokens,
                        num_logprobs, tp_size)


ers_no_consistency(self, consistency_view, store):
        """Test that nodes without consistency are filtered out."""
        # Add node without consistency
        node_data = StoreNodeData.new()
        store.nodes["no_consistency_node"] = node_data

        result = consistency_view.nodes()

        assert "no_consistency_node" not in result

    def test_nodes_filters_no_leader(self, consistency_view, store, second_signer):
        """Test that nodes without leader are filtered out."""
        node_data = StoreNodeData.new()
        node_data.consistency = StoreConsistencyData.new(second_signer)
        cons_ctx = StoreConsistentContextData.new(
            second_signer, "test_context", "test_ctx", None
        )
        cons_ctx.leader = None  # No leader
        node_data.consistency.consistent_contexts["test_context"] = cons_ctx
        store.nodes[second_signer.node_id] = node_data

        result = consistency_view.nodes()

        assert second_signer.node_id not in result

    def test_nodes_filters_no_verifier(self, consistency_view, store):
        """Test that nodes without verifier are filtered out."""
        third_signer = Signer("third_node", Ed25519PrivateKey.generate())
        node_data = StoreNodeData.new()
        node_data.consistency = StoreConsistencyData.new(third_signer)
        cons_ctx = StoreConsistentContextData.new(
            third_signer, "test_context", "test_ctx", None
        )

        leader_entry = StoreLeaderEntry(
            status=StoreLeaderStatus.FOLLOWER, node_id=third_signer.node_id
        )
        leader_signed = SignedBlockData.new(
            third_signer, leader_entry, "leader_status", secret=None
        )
        cons_ctx.leader = SignedBlockData.new(third_signer, leader_signed, "leader")

        node_data.consistency.consistent_contexts["test_context"] = cons_ctx
        store.nodes[third_signer.node_id] = node_data

        result = consistency_view.nodes()

        # third_node has no verifier in key_mapping
        assert third_signer.node_id not in result

class TestConsistencyContextEntry:
    """Test ConsistencyContextEntry model."""

    def test_consistency_context_entry(self, test_signer):
        """Test creating ConsistencyContextEntry."""
        test_data = SimpleTestModel(value="test", count=1)
        signed_block = SignedBlockData.new(test_signer, test_data, "key1")
        date = datetime.datetime.now(datetime.timezone.utc)

        entry = ConsistencyContextEntry(signed_block=signed_block, date=date)

        assert entry.signed_block == signed_block
        assert entry.date == date


) {}

/* Larger than tablet */
@media (min-width: 750px) {}

/* Larger than desktop */
@media (min-width: 1000px) {}

/* Larger than Desktop HD */
@media (min-width: 1200px) {}
/**
 * Copyright (c) 2012-2015 Net-ng.
 * All rights reserved.
 *
 * This software is licensed under the BSD License, as described in
 * the file LICENSE.txt, which you should have received as part of
 * this distribution.
 **/

/*Home page*/
.home {
    padding: 100px 20px 54px 0;
}

.home input:disabled {
    margin-bottom: 10px;
}

.home .boards a.archive,
.home .boards a.restore,
.home .boards a.delete,
.home .boards a.add,
.home .boards a.leave {
    display: inline-block;
    margin: 0;
    padding: 0;
    visibility: hidden;
}

.home .boards div.add {
    margin-right: 2px;
    vertical-align: middle;
    visibility: hidden;
}

.home .boards ul.board-labels li:hover .add,
.home .boards ul.board-labels li:hover a.archive,
.home .boards ul.board-labels li:hover a.restore,
.home .boards ul.board-labels li:hover a.delete,
.home .boards ul.board-labels li:hover a.add,
.home .boards ul.board-labels li:hover a.leave {
    visibility: visible;
}

.home .boards ul.board-labels {
    padding-left: 0;
    margin-bottom: 17px;
    max-width: 800px;
}

.home .boards ul.board-labels li {
    padding: 0 5px;
}

.home .boards ul.board-labels li .boardItemLabel {
    width: calc(100% - 220px);
    margin-bottom: 0;
    margin-top: 10px;
}

.home .boards ul.board-labels li .actions {
    display: inline-block;
    width: 220px;
    text-align: right;
}

.home .new-board {
    padding: 14px 10px;
}

.home .new-board select {
    width: auto;
}

.home .boards .list {
    height: auto;
}

.boards { margin-bottom: 50px; }

.boards input[type=text],
.boards input[type=password],
.boards input[type=file],
.boards select,
.boards textarea {
    width: 80%;
}

/* Board labels */
.boards .compact {
    display: none;
}

/* End board labels */

.info-message {
    display: block;
    position: relative;
}

/* Responsive medium size */
@media (max-width:813px) {
    .home { padding: 60px 20px 0 20px; }

    .home .menu {
        width: 100%;
    }

    .home .menu li {
        display: inline-block;
        padding: 0;
    }

    .home .menu a {
        padding: 10px 20px;
        margin: 0;
    }

    .home .menu, .home .boards { width: 100%; }

    form {
        width: 100%;
    }

    .boards input[type=text], .boards input[type=password], .boards input[type=file], .boards select, .boards textarea {
        width: 90%;
    }
}

/* Responsive small size */
@media all and (max-width:640px) {
    .home .boards .wide {
        display: none;
    }

    .home .boards .compact {
        display: inline-block;
    }

    .home .boards ul.board-labels li .boardItemLabel {
        width: calc(100% - 100px);
    }

    .home .boards ul.board-labels