(
        children: [
          Offstage(
            child: SizedBox(key: _globalKey, child: widget.builder.call(null)),
          ),
          widget.child,
        ],
      ),
    );
  }
}
import 'package:flutter/material.dart';
import 'package:flutter_openim_sdk/flutter_openim_sdk.dart';
import 'package:openim_common/openim_common.dart';
import 'package:sprintf/sprintf.dart';

class ChatReadTagView extends StatelessWidget {
  const ChatReadTagView({
    Key? key,
    required this.message,
    this.onTap,
  }) : super(key: key);
  final Message message;
  final Function()? onTap;

  int get _needReadMemberCount {
    final hasReadCount = message.attachedInfoElem?.groupHasReadInfo?.hasReadCount ?? 0;
    final unreadCount = message.attachedInfoElem?.groupHasReadInfo?.unreadCount ?? 0;
    return hasReadCount + unreadCount;
  }

  int get _unreadCount => message.attachedInfoElem?.groupHasReadInfo?.unreadCount ?? 0;

  bool get isRead => message.isRead!;

  @override
  Widget build(BuildContext context) {
    if (message.isSingleChat) {
      return (isRead ? StrRes.hasRead : StrRes.unread).toText..style = (isRead ? Styles.ts_8E9AB0_12sp : Styles.ts_0089FF_12sp);
    } else {
      if (_needReadMemberCount == 0) return const SizedBox();
      bool isAllRead = _unreadCount <= 0;
      return GestureDetector(
        onTap: onTap,
        behavior: HitTestBehavior.translucent,
        child: (isAllRead ? StrRes.allRead : sprintf(StrRes.nPersonUnRead, [_unreadCount])).toText
          ..style = (isAllRead ? Styles.ts_8E9AB0_12sp : Styles.ts_0089FF_12sp),
      );
    }
  }
}
import 'dart:io';

import 'package:extended_image/extended_image.dart';
import 'package:flutter/material.dart';

class ThumbnailViewer extends StatefulWidget {
  final String? thumbnailUrl;
  final String? imageUrl;
  final File? thumbnailFile;
  final File? imageFile;
  final VoidCallback? onTap;
  final VoidCallback? onLongPress;

  ThumbnailViewer({this.thumbnailUrl, this.imageUrl, this.thumbnailFile, this.imageFile, this.onTap, this.onLongPress});

  @override
  _ThumbnailViewerState createState() => _ThumbnailViewerState();
}

class _ThumbnailViewerState extends State<ThumbnailViewer> {
  bool showThumbnail = true;

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTap: widget.onTap,
      onLongPress: widget.onLongPress,
      child: Center(
        child: showThumbnail
            ? (widget.thumbnailFile != null
                ? ExtendedImage.file(
                    widget.thumbnailFile!,
                  )
                : ExtendedImage.network(
                    widget.thumbnailUrl!,
                    fit: BoxFit.cover,
                    loadStateChanged: (state) {
                      if (state.extendedImageLoadState == LoadState.completed) {
                        setState(() {
                          showThumbnail = false;
                        });
                      }
                      return null;
                    },
                  ))
            : (widget.imageFile != null
                ? ExtendedImage.file(widget.imageFile!)
                : ExtendedImage.network(
                    widget.


idth tier for the NodePool. [Valid values](https://cloud.google.com/kubernetes-engine/docs/reference/rest/v1/projects.locations.clusters.nodePools#NodePool.Tier) include: "TIER_1" and "TIER_UNSPECIFIED".
        /// </summary>
        public readonly string TotalEgressBandwidthTier;

        [OutputConstructor]
        private GetClusterNodePoolNetworkConfigNetworkPerformanceConfigResult(string totalEgressBandwidthTier)
        {
            TotalEgressBandwidthTier = totalEgressBandwidthTier;
        }
    }
}


       f.write(cursorrules_content)

        print("[Cursor 규칙 동기화] .cursorrules 파일 업데이트 완료")

        # components.md 파일도 생성 (문서용)
        components_md_content = cursorrules_content
        components_md_file = Path("components.md")
        with open(components_md_file, 'w', encoding='utf-8') as f:
            f.write(components_md_content)

        print("[Cursor 규칙 동기화] components.md 파일 업데이트 완료")

        print("[Cursor 규칙 동기화] 모든 규칙 파일이 업로드 준비되었습니다!")

    except Exception as e:
        print(f"[Cursor 규칙 동기화] 오류: {e}")
        print("수동으로 규칙 파일을 확인해주세요.")

def update_work_log(work_description):
    """작업 로그 업데이트"""
    log_file = Path("WORK_SESSION_LOG.md")
    today = datetime.now().strftime("%Y-%m-%d")
    timestamp = datetime.now().strftime("%H:%M")

    # 로그 파일이 없으면 생성
    if not log_file.exists():
        log_file.write_text(f"""# 작업 세션 로그

## {today}

### 집 (홈)
- [ ]

### 학원 (아카데미)
- [ ]

## 다음 작업 계획
- [ ]
- [ ]
""", encoding='utf-8')

    # 기존 로그 읽기
    content = log_file.read_text(encoding='utf-8')

    # 오늘 날짜 섹션이 없으면 추가
    if f"## {today}" not in content:
        content += f"\n## {today}\n\n### 집 (홈)\n- [ ] \n\n### 학원 (아카데미)\n- [ ] \n\n"

    # 작업 내용 추가 (간단한 형태)
    lines = content.split('\n')
    new_lines = []
    in_today_section = False

    for line in lines:
        new_lines.append(line)
        if f"## {today}" in line:
            in_today_section = True
        elif in_today_section and line.startswith("## "):
            # 다음 날짜 섹션을 만나면 오늘 섹션 종료
            in_today_section = False
        elif in_today_section and line.startswith("- [ ]") and not line.strip().endswith("- [ ]"):
            # 빈 작업 항목을 찾으면 작업 내용 추가
            new_lines.append(f"- [x] {work_description} ({timestamp})")

    # 로그 파일 업데이트
    log_file.write_text('\n'.join(new_lines), encoding='utf-8')
    print(f"작업 로그 업데이트: {work_description}")

def backup_mcp_settings():
    """MCP 설정 및 패키지 목록 백업"""
    print("\n[MCP 백업] 시작...")

    try:
        # .cursor 디렉토리 생성
        cursor_dir = Path(".cursor")
        cursor_dir.mkdir(exist_ok=True)

        # Cursor 설정 파일 백업
        import os
        cursor_settings_path = Path(os.environ['APPDATA']) / "Cursor" / "User" / "settings.json"
        if cursor_settings_path.exists():
            import shutil
            backup_path = cursor_dir / "cursor_settings.json"
            shutil.copy2(cursor_settings_path, backup_path)
            print("✅ Cursor 설정 파일 백업 완료")
        else:
            print("⚠ Cursor 설정 파일을 찾을 수 없습니다.")

        # MCP 패키지 목록 백업
        try:
            result = subprocess.run([sys.executable, "-m", "pip", "list"],
                                  capture_output=True, text=True, encoding='utf-8')
            if result.returncode == 0:
                # MCP 관련 패키지만 필터링
                mcp_packages = []
                for line in result.stdout.split('\n'):
                    if line.strip() and ('mcp' in line.lower() or 'model-context' in line.lower()):
                        mcp_packages.append(line.strip())

                if mcp_packages:
                    mcp_packages_file = cursor_dir / "mcp_packages.txt"
                    with open(mcp_packages_file, 'w', encoding='utf-8') as f:
                        f.write('\n'.join(mcp_packages))
                    print(f"✅ MCP 패키지 목록 백업 완료 ({len(mcp_packages)}개)")
                else:
                    print("📦 MCP 패키지가 설치되어 있지 않습니다.")
        except Exception as e:
            print(f"❌ MCP 패키지 목록 백업 실패: {e}")

        print("[MCP 백업] 완료!")

    except Exception as e:
        print(f"[MCP 백업] 오류: {e}")

def main():
    print("작업 종료 자동화 스크립트")
    print("=" * 50)

    # 작업 내용 입력 받기
    work_description = input("오늘 작업한 내용을 간단히 입력하세요: ").strip()
    if not work_description:
        work_description = "작업 완료"

    # 1. 변경사항 확인
    print("[변경사항 확인] 실행 중...")
    try:
        result = subprocess.run("git status --porcelain", shell=True, capture_output=True, text=True,
                              cwd=Path.cwd(), encoding='utf-8', errors='ignore')
        if result.returncode == 0:
            print("[변경사항 확인] 완료")
            if result.stdout and result.stdout.strip():
                print(f"   {result.stdout.strip()}")
                has_changes = True
            else:
                print("   변경사항 없음")
                has_changes = False
        else:
            print(f


uttonCell2'"))
    ..onClick.listen((ev) => _listAIS(ev));

  querySelector("#td_buttonCell3")
    ..onClick.listen((ev) => print("id:'td_buttonCell3'"))
    ..onClick.listen((ev) => _listENC(ev));

  // 'Switch to Touch'
  querySelector("#td_buttonCell4")
    ..onClick.listen((ev) => print("id:'td_buttonCell4'"))
    ..onClick.listen((ev) => _toggleUIEvent());

  querySelector("#r28")
    ..onClick.listen((ev) => print("id:'r28'"))
    ..onClick.listen((ev) => _handleInput(S52.MAR_ROT_BUOY_LIGHT, 0.0));

  // 'Switch To Menu'
  querySelector("#svg1menu")
    ..onClick.listen((ev) => print("id:'svg1menu'"))
    ..onClick.listen((ev) => _toggleUIEvent());

  print('s52ui.dart:_checkButton() - start - ');

  int startIdx = 0;
  Completer completer = new Completer();
  _initCheckBox(_checkButton, startIdx, "i", completer).then((ret) {
    completer = new Completer();
    startIdx = 0;
    _initNumBox(_numButton, startIdx, "I", completer);
  });

  return completer.future;
}

void _initTouch() {
  // Handle touch events.
  Element target = querySelector('#svg1');

  //bool doBlit1  = true;
  //bool doBlit2  = true;
  bool modeZoom = false;
  bool newTouch = false;

  int start_x1 = 0;
  int start_y1 = 0;
  int start_x2 = 0;
  //int start_y2 =  0;

  int new_x1 = -1;
  int new_y1 = -1;
  int new_x2 =  0;
  //int new_y2   =  0;

  int    ticks    = 0;
  double zoom_fac = 0.0;

  querySelector('#svg1g').onTouchStart.listen((ev) {
    _fullList(ev);
  });

  //print('s52ui.dart:_initTouch():target');
  print('s52ui.dart:_initTouch():target=$target');

  target.onTouchStart.listen((TouchEvent event) {
    event.preventDefault();
    s52.skipTimer = true;

    // Start of new Touch event cycle
    if (false == newTouch) {
      newTouch = true;
      modeZoom = false;
      zoom_fac = 0.0;
      ticks    = 0;
    }

    if (1 == event.touches.length) {
      start_x1 = event.touches[0].page.x;
      start_y1 = event.touches[0].page.y;

      //doBlit1  = true;
      //doBlit2  = false;

      // debug
      //print("onTouchStart start_x1:$start_x1, start_y1:$start_y1");
    }

    if (2 == event.touches.length) {
      start_x1 = event.touches[0].page.x;
      start_y1 = event.touches[0].page.y;
      start_x2 = event.touches[1].page.x;
      //start_y2 = event.touches[1].page.y;

      //doBlit1  = false;
      //doBlit2  = true;

      modeZoom = true;

      // debug
      //print("onTouchStart start_x2:$start_x2, start_y2:$start_y2");
    }
  });

  target.onTouchMove.listen((TouchEvent event) {
    event.preventDefault();

    ++ticks;


_decorator SM(&*v);
    SM.extract_interior();
  }
  Halffacet_iterator f;
  CGAL_forall_halffacets(f,D) f->mark() = false;

  simplify();
}

template <typename Kernel, typename Items, typename Mark>
void
Nef_polyhedron_3<Kernel,Items, Mark>::
extract_boundary() {
  CGAL_NEF_TRACEN("extract boundary");
  if (this->is_shared()) clone_rep();
  SNC_decorator D(snc());
  Vertex_iterator v;
  CGAL_forall_vertices(v,D) {
    v->mark() = true;
    SM_decorator SM(&*v);
    SM.extract_boundary();
  }
  Halffacet_iterator f;
  CGAL_forall_halffacets(f,D) f->mark() = true;
  Volume_iterator c;
  CGAL_forall_volumes(c,D) c->mark() = false;
  simplify();
}

} //namespace CGAL

#include <CGAL/enable_warnings.h>

#endif //CGAL_NEF_POLYHEDRON_3_H


r the current selection ({count} items left)","soldOut":"Sold Out","justSoldOut":"Just Sold Out","selectionSoldOut":"Selection Sold Out","subProductItemsLeft":"({count} items left)","startButtonText":"START","submitButtonText":"Submit","submissionLimit":"Sorry! Only one entry is allowed. Multiple submissions are disabled for this form.","reviewBackText":"Back to Form","seeAllText":"See All","progressMiddleText":"of","fieldError":"field has an error.","error":"Error"};
	JotForm.newPaymentUI = true;
	JotForm.replaceTagTest = true;

   JotForm.setConditions([{"action":[{"id":"action_1633895249090","visibility":"Show","isError":false,"field":"19"}],"id":"1633895262771","index":"0","link":"Any","priority":"0","terms":[{"id":"term_1633895249090","field":"8","operator":"equals","value":"Business","isError":false}],"type":"field"},{"action":[{"id":"action_1633895055450","visibility":"Show","isError":false,"field":"17"}],"id":"1633895077498","index":"1","link":"Any","priority":"1","terms":[{"id":"term_1633895071204","field":"8","operator":"equals","value":"Business","isError":false},{"id":"term_1633895055450","field":"8","operator":"equals","value":"Personal","isError":false}],"type":"field"},{"action":[{"id":"action_1496846929731","visibility":"ShowMultiple","isError":false,"fields":["13","14"]}],"id":"1496846951976","index":"2","link":"Any","priority":"2","terms":[{"id":"term_1496846929731","field":"12","operator":"equals","value":"NO","isError":false}],"type":"field"},{"action":[{"id":"action_0_1496854432421","visibility":"ShowMultiple","isError":false,"fields":["10","9","3","4","11","12","7","6"]}],"id":"1496846922032","index":"3","link":"Any","priority":"3","terms":[{"id":"term_0_1496854432421","field":"8","operator":"equals","value":"Business","isError":false}],"type":"field"},{"action":[{"id":"action_1496846577068","visibility":"ShowMultiple","isError":false,"fields":["1","3","4","5","7","6"]}],"id":"1496846624651","index":"4","link":"Any","priority":"4","terms":[{"id":"term_1496846577068","field":"8","operator":"equals","value":"Personal","isError":false}],"type":"field"}]);	JotForm.clearFieldOnHide="disable";
	JotForm.submitError="jumpToFirstError";
	window.addEventListener('DOMContentLoaded',function(){window.brandingFooter.init({"formID":83494475271263,"campaign":"powered_by_jotform_le","isCardForm":false,"isLegacyForm":false})});
	JotForm.init(function(){
	/*INIT-START*/
if (window.JotForm && JotForm.accessible) $('input_10').setAttribute('tabindex',0);
      JotForm.setPhoneMaskingValidator( 'input_4_full', '\u0028\u0023\u0023\u0023\u0029 \u0023\u0023\u0023\u002d\u0023\u0023\u0023\u0023' );
if (window.JotForm && JotForm.accessible) $('input_7').setAttribute('tabindex',0);
      setTimeout(function() {
          JotForm.initMultipleUploads();
      }, 2);
	/*INIT-END*/
	});

   setTimeout(function() {
JotForm.paymentExtrasOnTheFly([null,{"description":"","name":"name","qid":"1","text":"Name","type":"control_fullname"},null,{"description":"","name":"contactEmail","qid":"3","subLabel":"example@example.com","text":"Contact E-mail","type":"control_email"},{"description":"","name":"phoneNumber","qid":"4","text":"Phone Number","type":"control_phone"},{"description":"","name":"address","qid":"5","text":"Address","type":"control_address"},{"name":"submit","qid":"6","text":"Submit","type":"control_button"},{"description":"","name":"pleaseAdvise","qid":"7","subLabel":"","text":"PLEASE ADVISE US OF ANY SPECIAL INSTRUCTIONS OR RESTRICTIONS:","type":"control_textarea"},{"description":"","name":"clickTo","qid":"8","text":"What type of account would you like to open? ","type":"control_radio"},{"description":"","name":"contactName","qid":"9","text":"Contact Name","type":"control_fullname"},{"description":"","name":"businessName","qid":"10


ceInfo::participant_list_t resources;
#ifdef HAVE_ADVANCED_IM
	if ((content.getContentType() == ContentType::ResourceLists) &&
	    ((content.getContentDisposition().weakEqual(ContentDisposition::RecipientList)) ||
	     (content.getContentDisposition().weakEqual(ContentDisposition::RecipientListHistory)))) {
		std::istringstream data(content.getBodyAsString());
		std::unique_ptr<Xsd::ResourceLists::ResourceLists> rl(
		    Xsd::ResourceLists::parseResourceLists(data, Xsd::XmlSchema::Flags::dont_validate));
		for (const auto &l : rl->getList()) {
			for (const auto &entry : l.getEntry()) {
				Address address(entry.getUri());
				auto basicAddress = Address::create(address.getUri());
				ParticipantInfo::participant_params_t params;
				for (const auto &[name, value] : address.getUriParams()) {
					params[name] = value;
					basicAddress->removeUriParam(name);
				}
				auto participantInfo = ParticipantInfo::create(basicAddress);
				participantInfo->setParameters(params);
				resources.push_back(participantInfo);
			}
		}
		return resources;
	}
	return resources;
#else
	lWarning() << "Advanced IM such as group chat is disabled!";
	return resources;
#endif
}
#ifndef _MSC_VER
#pragma GCC diagnostic pop
#endif // _MSC_VER

std::shared_ptr<ConferenceInfo> Utils::createConferenceInfoFromOp(SalCallOp *op, bool remote) {
	std::shared_ptr<ConferenceInfo> info = ConferenceInfo::create();
	if (!op) return info;
	const auto sipfrag = op->getContentInRemote(ContentType::SipFrag);
	const auto resourceList = op->getContentInRemote(ContentType::ResourceLists);

	if (sipfrag) {
		auto organizerStr = Utils::getSipFragAddress(sipfrag.value());
		auto organizer = Address::create(organizerStr);
		auto organizerInfo = ParticipantInfo::create(Address::create(organizer->getUri()));
		for (const auto &[name, value] : organizer->getParams()) {
			organizerInfo->addParameter(name, value);
		}
		info->setOrganizer(organizerInfo);
	}

	if (resourceList) {
		auto invitees = Utils::parseResourceLists(resourceList);
		for (const auto &invitee : invitees) {
			info->addParticipant(invitee);
		}
	}

	const std::shared_ptr<Address> conferenceAddress = Address::create();
	conferenceAddress->setImpl(remote ? op->getRemoteContactAddress() : op->getContactAddress());
	if (conferenceAddress && conferenceAddress->isValid()) {
		info->setUri(conferenceAddress);
	}

	auto &md = remote ? op->getRemoteMediaDescription() : op->getLocalMediaDescription();
	if (md && md->times.size() > 0) {
		const auto [startTime, endTime] = md->times.front();
		if (startTime >= 0) {
			info->setDateTime(startTime);
		} else {
			info->setDateTime(ms_time(NULL));
		}
		if ((startTime >= 0) && (endTime >= 0) && (endTime > startTime)) {
			unsigned int duration = (static_cast<unsigned int>(endTime - startTime)) / 60;
			info->setDuration(duration);
		}
	}

	info->setUtf8Subject(op->getSubject());

	return info;
}

std::string Utils::computeHa1ForAlgorithm(const std::string &userId,
                                          const std::string &password,
                                          const std::string &realm,
                                          const std::string &algorithm) {
	if (algorithm.empty() || algorithm == "MD5") {
		char ha1[33];
		if (sal_auth_compute_ha1(userId.c_str(), realm.c


}
import { INodeInput, NodeType } from "./node.interface";
/**
 * @class GraphStruct
 * Frame parent-class to simplify graph
 * elements recognition
 */
export declare class GraphStruct<T> {
    protected _list: INodeInput<T>[];
    private _nodesMap;
    private _incomesByNodeIdMap;
    private _outcomesByNodeIdMap;
    private _loopsByNodeIdMap;
    constructor(list: INodeInput<T>[]);
    /**
     * Fill graph with new nodes
     * @param list input linked list of nodes
     */
    applyList(list: INodeInput<T>[]): void;
    detectIncomesAndOutcomes(): void;
    traverseVertically(node: INodeInput<T>, branchSet: Set<string>, totalSet: Set<string>): Set<string>;
    /**
     * Get graph roots.
     * Roots is nodes without incomes
     */
    roots(): INodeInput<T>[];
    /**
     * Get type of node
     * @param id id of node
     * @returns type of the node
     */
    protected nodeType(id: string): NodeType;
    /**
     * Whether or node is split
     * @param id id of node
     */
    private isSplit;
    /**
     * Whether or node is join
     * @param id id of node
     */
    private isJoin;
    /**
     * Whether or node is root
     * @param id id of node
     */
    private isRoot;
    protected isLoopEdge(nodeId: string, outcomeId: string): boolean;
    /**
     * Get loops of node by id
     * @param id id of node
     */
    protected loops(id: string): string[];
    /**
     * Get outcomes of node by id
     * @param id id of node
     */
    protected outcomes(id: string): string[];
    /**
     * Get incomes of node by id
     * @param id id of node
     */
    protected incomes(id: string): string[];
    /**
     * Get node by id
     * @param id node id
     */
    protected node(id: string): INodeInput<T>;
    /**
     * get outcomes inputs helper
     * @param itemId node id
     */
    protected getOutcomesArray(itemId: string): INodeInput<T>[];
}
export class InvalidArgument extends Error {
  constructor(argumentName: string) {
    super();
    super.message = `The argument name: ${argumentName} is invalid`;
  }
}
import { ModalType } from '../../type';
import { RootState } from '../index';
import { createSlice } from '@reduxjs/toolkit';

const initialState: ModalType = {
  isOpen: false,
  date: '',
};

export const modalSlice = createSlice({
  name: 'modal',
  initialState,
  reducers: {
    openModal(state) {
      state.isOpen = true;
    },
    closeModal(state) {
      state.isOpen = false;
    },
    setDate(state, action) {
      state.date = action.payload.date;
    },
  },
});

export const { openModal, closeModal, setDate } = modalSlice.actions;
export const selectIsOpen = (state: RootState): boolean => state.modal.isOpen;
export const selectDate = (state: RootState): string => state.modal.date;

export default modalSlice.reducer;
import { Soort } from "./soort";
import { Observable } from "rxjs/Rx";

export class Animal {

    private _id: string;
    private _name: string;
    private _male: boolean
    private _birthdate: Date;
    private _soort: Soort
    private _food: number;
    private _pleasure: number;
    private _drink: number;
    private _petted: boolean = false;
    private _lastFoodUpdate: Date;
    private _lastDrinkUpdate: Date;
    private _lastPleasureUpdate: Date;
    private _ali


 .antd-Log .ansi-blue-fg,
.amis-scope .antd-Log .ansi-bright-blue-fg {
  color: #96cbfe;
}

.amis-scope .antd-Log .ansi-magenta-fg,
.amis-scope .antd-Log .ansi-bright-magenta-fg {
  color: #ff73fd;
}

.amis-scope .antd-Log .ansi-cyan-fg,
.amis-scope .antd-Log .ansi-bright-cyan-fg {
  color: #5ff;
}

.amis-scope .antd-Log .ansi-white-fg,
.amis-scope .antd-Log .ansi-bright-white-fg {
  color: #eee;
}

.amis-scope .antd-Log .ansi-grey-fg,
.amis-scope .antd-Log .ansi-bright-grey-fg {
  color: #969696;
}

.amis-scope .antd-Log .ansi-black-bg {
  background-color: #4e4e4e;
}

.amis-scope .antd-Log .ansi-red-bg {
  background-color: #ff6c60;
}

.amis-scope .antd-Log .ansi-green-bg {
  background-color: #0a0;
}

.amis-scope .antd-Log .ansi-yellow-bg {
  background-color: #ffffb6;
}

.amis-scope .antd-Log .ansi-blue-bg {
  background-color: #96cbfe;
}

.amis-scope .antd-Log .ansi-magenta-bg {
  background-color: #ff73fd;
}

.amis-scope .antd-Log .ansi-cyan-bg {
  background-color: #0aa;
}

.amis-scope .antd-Log .ansi-white-bg {
  background-color: #eee;
}

.amis-scope .antd-JsonField-nodeValue {
  white-space: normal;
  word-break: break-all;
  overflow-wrap: break-word;
}

.amis-scope .antd-Icon {
  height: 0.875rem;
  vertical-align: middle;
}

.amis-scope .antd-Steps {
  display: flex;
  list-style: none;
  padding: 0;
}

.amis-scope .antd-Steps .antd-StepsItem {
  flex: 1;
  overflow: hidden;
  padding: 0 1.25rem;
  height: auto;
  line-height: 2rem;
}

.amis-scope .antd-Steps .antd-StepsItem-containerIcon {
  vertical-align: top;
  display: inline-block;
  padding-right: 0.625rem;
}

.amis-scope .antd-Steps .antd-StepsItem-containerIcon .antd-StepsItem-icon {
  display: inline-block;
  width: 1.875rem;
  height: 1.875rem;
  line-height: 1.75rem;
  border-radius: 50%;
  font-size: 1rem;
  text-align: center;
}

.amis-scope .antd-Steps .antd-StepsItem-containerWrapper {
  display: inline-block;
  position: relative;
}

.amis-scope .antd-Steps .antd-StepsItem-containerWrapper .antd-StepsItem-body .antd-StepsItem-title {
  font-size: 1rem;
  color: #333;
  padding-right: 1.25rem;
  position: relative;
  display: inline-block;
}

.amis-scope .antd-Steps .antd-StepsItem-containerWrapper .antd-StepsItem-body .antd-StepsItem-title > span {
  display: inline-block;
}

.amis-scope .antd-Steps


32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,


 Discrete Gaussian Distribution
// with varying center and fixed, small stdDev.
type TwinCDTSampler struct {
	Parameters Parameters

	*csprng.TwinCDTSampler
}

// NewTwinCDTSampler creates a new TwinCDTSampler.
//
// Panics when read from crypto/rand or blake2b initialization fails.
func NewTwinCDTSampler(params Parameters, stdDev float64) *TwinCDTSampler {
	return &TwinCDTSampler{
		Parameters:     params,
		TwinCDTSampler: csprng.NewTwinCDTSampler(stdDev),
	}
}

// ShallowCopy creates a copy of Sampler that is thread-safe.
func (s *TwinCDTSampler) ShallowCopy() *TwinCDTSampler {
	return &TwinCDTSampler{
		Parameters:     s.Parameters,
		TwinCDTSampler: s.TwinCDTSampler.ShallowCopy(),
	}
}

// SamplePoly samples a polynomial from the Discrete Gaussian Distribution.
func (s *TwinCDTSampler) SamplePoly(center float64) ring.Poly {
	pOut := s.Parameters.ringQ.NewPoly()
	s.SamplePolyAssign(center, pOut)
	return pOut
}

// SamplePolyAssign samples a polynomial from the Discrete Gaussian Distribution and assigns it to pOut.
func (s *TwinCDTSampler) SamplePolyAssign(center float64, pOut ring.Poly) {
	for i := 0; i < s.Parameters.ringQ.N(); i++ {
		c := s.Sample(center)
		if c >= 0 {
			for j := 0; j <= s.Parameters.ringQ.Level(); j++ {
				pOut.Coeffs[j][i] = uint64(c)
			}
		} else {
			for j := 0; j <= s.Parameters.ringQ.Level(); j++ {
				pOut.Coeffs[j][i] = uint64(c + int64(s.Parameters.ringQ.SubRings[j].Modulus))
			}
		}
	}

	s.Parameters.ringQ.NTT(pOut, pOut)
	s.Parameters.ringQ.MForm(pOut, pOut)
}
package celpc

import (
	"math"
	"math/big"
	"runtime"
	"sync"

	"github.com/sp301415/ringo-snark/bigring"
	"github.com/tuneinsight/lattigo/v6/ring"
)

// Prover is a prover for polynomial commitment.
type Prover struct {
	Parameters Parameters
	Reducer    *bigring.Reducer

	StreamSampler   *StreamSampler
	GaussianSampler *COSACSampler
	Oracle          *RandomOracle

	Encoder  *Encoder
	Commiter *AjtaiCommiter

	CommitEncoder     *EncoderFixedStdDev
	CommitRandSampler *TwinCDTSampler

	buffer proverBuffer
}

type proverBuffer struct {
	bigBlind      []*big.Int
	bigBlindShift []*big.Int

	bigMask   []*big.Int
	challenge ring.Poly

	mul *big.Int

	exp     *big.Int
	xEcd    ring.Poly
	xPowEcd ring.Poly

	xPow     *big.Int
	xPowSkip *big.Int

	xPowBasis []*big.Int
	maskDcd   []*big.Int
}

// NewProver creates a new Prover.
func NewProver(params Parameters, ck AjtaiCommitKey) *Prover {
	return &Prover{
		Parameters: params,
		Reducer:    bigring.NewReducer(params.modulus),

		StreamSampler:   NewStreamSampler(params),
		GaussianSampler: NewCOSACSampler(params),
		Oracle:          NewRandomOracle(params),

		Encoder:  NewEncoder


 bucket using the influx CLI

Use the [`influx bucket update` command](/influxdb3/cloud-serverless/reference/cli/influx/bucket/update)
to update a bucket.
Updating a bucket requires the following:

- The bucket ID _(provided in the output of `influx bucket list`)_

{{< cli/influx-creds-note >}}

##### Update the name of a bucket

```sh
# Syntax
influx bucket update -i <bucket-id> -n <new-bucket-name>

# Example
influx bucket update -i 034ad714fdd6f000 -n my-new-bucket
```

##### Update a bucket's retention period

Valid retention period duration units:

- nanoseconds (`ns`)
- microseconds (`us` or `µs`)
- milliseconds (`ms`)
- seconds (`s`)
- minutes (`m`)
- hours (`h`)
- days (`d`)
- weeks (`w`)

> [!Note]
> The minimum retention period is **one hour**.

```sh
# Syntax
influx bucket update -i <bucket-id> -r <retention period with units>

# Example
influx bucket update -i 034ad714fdd6f000 -r 1209600000000000ns
```

## Update a bucket using the HTTP API

Use the InfluxDB HTTP API [`PATCH /api/v2/buckets` endpoint](/influxdb3/cloud-serverless/api/#operation/PatchBucketsID)
to update a bucket.

Updating a bucket requires the following:

- The bucket ID _(provided in the output of the `GET /api/v2/buckets/` endpoint)_

You can update the following bucket properties:
- name
- description
- retention rules

1. To find the bucket ID, send a request to the HTTP API [`GET /api/v2/buckets/` endpoint](/influxdb3/cloud-serverless/api/#operation/GetBuckets) to retrieve the list of buckets. <!-- @TODO: provide API auth note about tokens and read access to buckets -->

    {{< api-endpoint method="get" endpoint="https://{{< influxdb/host >}}/api/v2/buckets" api-ref="/influxdb3/cloud-serverless/api/#operation/GetBuckets" >}}

2. Send a request to the HTTP API [PATCH `/api/v2/buckets/{BUCKET_ID}` endpoint](/influxdb3/cloud-serverless/api/#operation/PatchBucketsID).

    In the URL path, specify the ID of the bucket from the previous step that you want to update.
    In the request body, set the properties that you want to update--for example:

    {{< api-endpoint method="patch" endpoint="https://{{< influxdb/host >}}/api/v2/buckets/{BUCKET_ID}" api-ref="/influxdb3/cloud-serverless/api/#operation/PatchBucketsID" >}}

    ```js
    {
      "name": "air_sensor",
      "description": "bucket holding air sensor data",
      "retentionRules": [
          {
              "type": "expire",
              "everySeconds": 2592000
          }
      ]
    }
    ```
---
title: Use the InfluxDB v2 API with InfluxDB Cloud Serverless
list_title: InfluxDB v2 API compatibility
description: >
  Use the InfluxDB v2 API for new write workloads and existing v2 write workloads.
  InfluxDB Cloud Serverless is compatible with the InfluxDB v2 API `/api/v2/write` endpoint and existing InfluxDB 2.x tools and code.
weight: 1
menu:
  influxdb3_cloud_serverless:
    parent: API compatibility
    name: v2 API
influxdb3/cloud-serverless/tags: [write, line protocol]
aliases:
  - /influxdb3/cloud-serverless/primers/api/v2/
  - /influxdb3/cloud-serverless/api-compatibility/v2/
related:
  - /influxdb3/cloud-serverless/query-data/sql/
  - /influxdb3/cloud-serverless/query-data/influxql/
  - /influxdb3/cloud-serverless/write-data/
  - /


-----------------------------------
-- Area: Northern San d'Oria
--  NPC: Morjean
-- Involved in Quest: A Squire's Test II (Optional), The Holy Crest
-- !pos 99 0 116 231
-------------------------------------
require("scripts/globals/settings")
require("scripts/globals/quests")
-----------------------------------

function onTrade(player, npc, trade)
end

function onTrigger(player, npc)

    local TheHolyCrest = player:getCharVar("TheHolyCrest_Event")

    if (TheHolyCrest == 2) then
        player:startEvent(65)
    elseif ((TheHolyCrest == 3 and player:hasItem(1159)) or TheHolyCrest == 4)


.format!.formatting(
            HentaiDonwloadManager.instance().defaultFormat(),
          ),
        );
      }
    } catch (e) {
      _setState(7);
      return;
    }
  }

  Future<bool> checkNothingToDownload() async {
    if (tasks == null || tasks!.isEmpty) {
      await _setState(11);
      return true;
    }
    return false;
  }

  Future<void> extractFilePath() async {
    final files = tasks!.map((e) => e.downloadPath!).toList();
    result['Files'] = jsonEncode(files);
    result['Path'] = _extractSuperPath(files);
    await _updateItem();
  }

  String _extractSuperPath(List<String> files) {
    var cp = dirname(files[0]).split('/');
    var vp = cp.length;
    for (int i = 1; i < files.length; i++) {
      var tp = dirname(files[i]).split('/');
      for (int i = 0; i < vp; i++) {
        if (cp[i] != tp[i]) {
          vp = i;
          break;
        }
      }
    }
    return cp.take(vp).join('/');
  }

  Future<void> appendDownloadTasks({
    required VoidCallback completeCallback,
    required DoubleCallback downloadCallback,
    required VoidStringCallback errorCallback,
  }) async {
    final downloader = await IsolateDownloader.getInstance();

    downloader.appendTasks(
      tasks!.map((e) {
        e.startCallback = () {};
        e.completeCallback = completeCallback;

        e.sizeCallback = (byte) {};
        e.downloadCallback = downloadCallback;

        e.errorCallback = errorCallback;

        return e;
      }).toList(),
    );

    await _setState(3);
  }

  Future<List<int>> checkDownloadFiles() async {
    final files = tasks!.map((e) => e.downloadPath!).toList();
    final invalidIndex = <int>[];

    for (var i = 0; i < files.length; i++) {
      var file = File(files[i]);

      if (!await file.exists()) {
        invalidIndex.add(i);
        continue;
      }

      if (await file.length() < 5) {
        invalidIndex.add(i);
        await file.delete();
        continue;
      }
    }

    return invalidIndex;
  }

  Future<void> retryInvalidDownloadFiles(
    List<int> invalidIndex, {
    required VoidCallback completeCallback,
    required DoubleCallback downloadCallback,
    required VoidStringCallback errorCallback,
  }) async {
    final downloader = await IsolateDownloader.getInstance();

    downloader.appendTasks(
      invalidIndex.map((e) => tasks![e]).map((e) {
        e.startCallback = () {};
        e.completeCallback = completeCallback;

        e.sizeCallback = (byte) {};
        e.downloadCallback = downloadCallback;

        e.errorCallback = errorCallback;

        return e;
      }).toList(),
    );

    await _setState(3);
  }

  Future<void> setDownloadComplete() async {
    (await Download.getInstance()).appendDownloaded(
      int.parse(item.url()),
      item,
    );
    await _setState(0);
  }

  Future<void> _setState(int state) async {
    result['State'] = state;
    await _updateItem();
  }

  Future<void> _updateItem() async {
    item.result = result;
    await item.update();
    setStateCallback.call();
  }

  Future<String> downloadBasePath() async {
    if (Settings.useInnerStorage.value) {
      return (await getApplicationDocumentsDirectory()).path;
    } else {
      return Settings.downloadBasePath.value;
    }
  }
}
// This source code is a part of Project Violet.
// Copyright (C) 2020-2024. violet-team. Licensed under the Apache-2.0 License.

// ignore_for_file: use


, %xmm6
	addps	 %xmm6,  %xmm1

	mulps	 %xmm13, %xmm5
	SUBPS	 %xmm5,  %xmm0
	mulps	 %xmm13, %xmm7
	SUBPS	 %xmm7,  %xmm1

	MOVUPS_A2(-32 * SIZE, A2, LDA, 1, %xmm4)
	MOVUPS_A2(-28 * SIZE, A2, LDA, 1, %xmm6)

	pshufd	 $0xb1, %xmm4, %xmm5
	mulps	 %xmm14, %xmm4
	addps	 %xmm4,  %xmm0
	pshufd	 $0xb1, %xmm6, %xmm7
	mulps	 %xmm14, %xmm6
	addps	 %xmm6,  %xmm1

	mulps	 %xmm15, %xmm5
	SUBPS	 %xmm5,  %xmm0
	mulps	 %xmm15, %xmm7
	SUBPS	 %xmm7,  %xmm1

	movaps	 %xmm0, -32 * SIZE(Y1)
	movaps	 %xmm1, -28 * SIZE(Y1)

	movaps	 %xmm2, %xmm0
	movaps	 %xmm3, %xmm1

	addq	 $8 * SIZE, A1
	addq	 $8 * SIZE, A2
	addq	 $8 * SIZE, Y1
	ALIGN_3

.L17:
	testq	$2, MM
	je	.L18

	MOVUPS_A1(-32 * SIZE, A1, %xmm4)
	MOVUPS_A2(-32 * SIZE, A1, LDA, 1, %xmm6)

	pshufd	 $0xb1, %xmm4, %xmm5
	mulps	 %xmm8,  %xmm4
	addps	 %xmm4,  %xmm0
	MOVUPS_A1(-32 * SIZE, A2, %xmm4)
	pshufd	 $0xb1, %xmm6, %xmm7
	mulps	 %xmm9,  %xmm5
	SUBPS	 %xmm5,  %xmm0

	mulps	 %xmm10, %xmm6
	addps	 %xmm6,  %xmm0
	MOVUPS_A2(-32 * SIZE, A2, LDA, 1, %xmm6)
	mulps	 %xmm11, %xmm7
	SUBPS	 %xmm7,  %xmm0

	pshufd	 $0xb1, %xmm4, %xmm5
	mulps	 %xmm12, %xmm4
	addps	 %xmm4,  %xmm0
	pshufd	 $0xb1, %xmm6, %xmm7
	mulps	 %xmm13, %xmm5
	SUBPS	 %xmm5,  %xmm0

	mulps	 %xmm14, %xmm6
	addps	 %xmm6,  %xmm0
	mulps	 %xmm15, %xmm7
	SUBPS	 %xmm7,  %xmm0

	movaps	 %xmm0, -32 * SIZE(Y1)
	movaps	 %xmm1, %xmm0

	addq	 $4 * SIZE, A1
	addq	 $4 * SIZE, A2
	addq	 $4 * SIZE, Y1
	ALIGN_3

.L18:
	testq	$1, MM
	je	.L19

	movsd	 -32 * SIZE(A1), %xmm4
	movsd	 -32 * SIZE(A1, LDA), %xmm6

	pshufd	 $0xb1, %xmm4, %xmm5
	mulps	 %xmm8,  %xmm4
	addps	 %xmm4,  %xmm0
	movsd	 -32 * SIZE(A2), %xmm4
	pshufd	 $0xb1, %xmm6, %xmm7
	mulps	 %xmm9,  %xmm5
	SUBPS	 %xmm5,  %xmm0

	mulps	 %xmm10, %xmm6
	addps	 %xmm6,  %xmm0
	mo


 code: ${result.exitCode}');
    print('stdout:');
    print(result.stdout);
    print('stderr:');
    print(result.stderr);
    command = dart2JsCommand([
      '--input-dill=json/world.dill',
      '--closed-world-data=json/world.data',
      '--global-inference-data=json/global.data',
      '--codegen-data=codegen',
      '--codegen-shards=1',
      '--out=out.js',
      '--dump-info-data=json/dump.data',
      '--stage=emit-js',
      'swarm.dart',
    ]);
    print('Run $command');
    result = Process.runSync(
      Platform.resolvedExecutable,
      command,
      workingDirectory: tmpDir.path,
    );
    print('exit code: ${result.exitCode}');
    print('stdout:');
    print(result.stdout);
    print('stderr:');
    print(result.stderr);
    command = dart2JsCommand([
      '--input-dill=json/world.dill',
      '--closed-world-data=json/world.data',
      '--global-inference-data=json/global.data',
      '--codegen-data=codegen',
      '--codegen-shards=1',
      '--dump-info-data=json/dump.data',
      '--stage=dump-info',
      'swarm.dart',
    ]);
    print('Run $command');
    result = Process.runSync(
      Platform.resolvedExecutable,
      command,
      workingDirectory: tmpDir.path,
    );
    print('exit code: ${result.exitCode}');
    print('stdout:');
    print(result.stdout);
    print('stderr:');
    print(result.stderr);
    Expect.equals(0, result.exitCode);
    String output4 = File.fromUri(
      tmpDir.uri.resolve('json/out.js'),
    ).readAsStringSync();
    String dumpInfoJson2 = File.fromUri(
      tmpDir.uri.resolve('json/out.js.info.json'),
    ).readAsStringSync();

    command = dart2JsCommand([
      '--input-dill=json/world.dill',
      '--closed-world-data=json/world.data',
      '--global-inference-data=json/global.data',
      '--codegen-data=codegen',
      '--codegen-shards=1',
      '--dump-info-data=json/dump.data',
      '--dump-info=binary',
      '--stage=dump-info',
      'swarm.dart',
    ]);
    print('Run $command');
    result = Process.runSync(
      Platform.resolvedExecutable,
      command,
      workingDirectory: tmpDir.path,
    );
    print('exit code: ${result.exitCode}');
    print('stdout:');
    print(result.stdout);
    print('stderr:');
    print(result.stderr);
    Expect.equals(0, result.exitCode);
    String output5 = File.fromUri(
      tmpDir.uri.resolve('json/out.js'),
    ).readAsStringSync();
    List<int> dumpInfoBinary2 = File.fromUri(
      tmpDir.uri.resolve('binary/out.js.info.data'),
    ).readAsBytesSync();

    print('Compare outputs...');
    Expect.equals(output1, output4);
    Expect.equals(output1, output5);
    Expect.equals(dumpInfoJson1, dumpInfoJson2);
    Expect.listEquals(dumpInfoBinary1, dumpInfoBinary2);

    print('Done');
  } finally {
    print("Deleting '${tmpDir.path}'.");
    tmpDir.deleteSync(recursive: true);
  }
}
// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can


("List all addon", func() {
			output, err := e2e.Exec("vela addon list")
			Expect(err).NotTo(HaveOccurred())
			Expect(output).To(ContainSubstring("test-addon"))
		})

		It("Enable addon test-addon", func() {
			output, err := e2e.Exec("vela addon enable test-addon")
			Expect(err).NotTo(HaveOccurred())
			Expect(output).To(ContainSubstring("enabled successfully."))
		})

		It("Upgrade addon test-addon", func() {
			output, err := e2e.Exec("vela addon upgrade test-addon")
			Expect(err).NotTo(HaveOccurred())
			Expect(output).To(ContainSubstring("enabled successfully."))
		})

		It("Disable addon test-addon", func() {
			output, err := e2e.LongTimeExec("vela addon disable test-addon", 600*time.Second)
			Expect(err).NotTo(HaveOccurred())
			Expect(output).To(ContainSubstring("Successfully disable addon"))
			Eventually(func(g Gomega) {
				g.Expect(apierrors.IsNotFound(k8sClient.Get(context.Background(), types.NamespacedName{Name: "addon-test-addon", Namespace: "vela-system"}, &v1beta1.Application{}))).Should(BeTrue())
				g.Expect(apierrors.IsNotFound(k8sClient.Get(context.Background(), types.NamespacedName{Name: "addon-secret-test-addon", Namespace: "vela-system"}, &v1.Secret{}))).Should(BeTrue())
			}, 60*time.Second).Should(Succeed())
		})

		It("Enable addon with input", func() {
			output, err := e2e.LongTimeExec("vela addon enable test-addon example=redis", 300*time.Second)
			Expect(err).NotTo(HaveOccurred())
			Expect(output).To(ContainSubstring("enabled successfully."))
		})

		It("Enable addon with specified registry ", func() {
			output, err := e2e.LongTimeExec("vela addon enable KubeVela/test-addon", 300*time.Second)
			Expect(err).NotTo(HaveOccurred())
			Expect(output).To(ContainSubstring("enabled successfully."))
		})

		It("Disable addon test-addon", func() {
			output, err := e2e.LongTimeExec("vela addon disable test-addon", 600*time.Second)
			Expect(err).NotTo(HaveOccurred())
			Expect(output).To(ContainSubstring("Successfully disable addon"))
			Eventually(func(g Gomega) {
				g.Expect(apierrors.IsNotFound(k8sClient.Get(context.Background(), types.NamespacedName{Name: "addon-test-addon", Namespace: "vela-system"}, &v1beta1.Application{}))).Should(BeTrue())
			}, 60*time.Second).Should(Succeed())
		})

		It("Enable local addon with . as path", func() {
			output, err := e2e.LongTimeExec("vela addon enable ../../e2e/addon/mock/testdata/sample/.", 600*time.Second)
			Expect(err).NotTo(HaveOccurred())
			Expect(output).To(ContainSubstring("sample enabled successfully."))
		})

		It("Test Change default namespace can work", func() {
			output, err := e2e.LongTimeExecWithEnv("vela addon list", 600*time.Second, []string{"DEFAULT_VELA_NS=test-vela"})
			Expect(err).NotTo(HaveOccurred())
			Expect(output).To(ContainSubstring("test-addon"))
			Expect(output).To(Cont


rt org.meshtastic.core.network.service.createApiService
import java.io.File
import javax.inject.Singleton

@InstallIn(SingletonComponent::class)
@Module
class GoogleNetworkModule {

    @Provides
    @Singleton
    fun provideOkHttpClient(@ApplicationContext context: Context): OkHttpClient = OkHttpClient.Builder()
        .cache(
            cache =
            Cache(
                directory = File(context.applicationContext.cacheDir, "http_cache"),
                maxSize = 50L * 1024L * 1024L, // 50 MiB
            ),
        )
        .addInterceptor(
            interceptor =
            HttpLoggingInterceptor().apply {
                if (BuildConfig.DEBUG) {
                    setLevel(HttpLoggingInterceptor.Level.BODY)
                }
            },
        )
        .addInterceptor(interceptor = DatadogInterceptor.Builder(tracedHosts = listOf("meshtastic.org")).build())
        .eventListenerFactory(eventListenerFactory = DatadogEventListener.Factory())
        .build()

    @Provides
    @Singleton
    fun provideHttpClient(okHttpClient: OkHttpClient): HttpClient = HttpClient(engineFactory = OkHttp) {
        engine { preconfigured = okHttpClient }

        install(plugin = ContentNegotiation) {
            json(
                Json {
                    isLenient = true
                    ignoreUnknownKeys = true
                },
            )
        }
    }

    @Provides
    @Singleton
    fun provideApiService(httpClient: HttpClient): ApiService {
        val ktorfit = Ktorfit.Builder().baseUrl(url = "https://api.meshtastic.org/").httpClient(httpClient).build()
        return ktorfit.createApiService()
    }
}
/*
 * Copyright (c) 2025 Meshtastic LLC
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package org.meshtastic.core.database.model

import androidx.annotation.StringRes
import org.meshtastic.core.database.entity.Reaction
import org.meshtastic.core.model.MessageStatus
import org.meshtastic.core.strings.R
import org.meshtastic.proto.MeshProtos.Routing

@Suppress("CyclomaticComplexMethod")
@StringRes
fun getStringResFrom(routingError: Int): Int = when (routingError) {
    Routing.Error.NONE_VALUE -> R.string.routing_error_none
    Routing.Error.NO_ROUTE_VALUE -> R.string.routing_error_no_route
    Routing.Error.GOT_NAK_VALUE -> R.string.routing_error_got_nak
    Routing.Error.TIMEOUT_VALUE -> R.string.routing_error_timeout
    Routing.Error.NO_INTERFACE_VALUE -> R.string.routing_error_no_interface
    Routing.Error.MAX_RETRANSMIT_VALUE -> R.string.routing_error_max_retransmit
    Routing.Error.NO_CHANNEL_VALUE -> R.string.routing_error_no_channel
    Routing.Error.TOO_LARGE_VALUE -> R.string.routing_error_too_large
    Routing.Error.NO_RESPONSE_VALUE -> R.string.routing_error_no_response
    Routing.Error.DUTY_CYCLE_LIMIT_VALUE -> R.string.routing_error_duty_cycle_limit
    Routing.Error.BAD_REQUEST_VALUE -> R.string.routing_error_bad_request
    Routing.Error.NOT_AUTHORIZED_VALUE -> R.string.routing


serverTimeData == nil then
      self.worldBossVM_:OpenWorldBossScheduleView()
    else
      local nowTimeSec = Z.TimeTools.Now() / 1000
      if nowTimeSec < serverTimeData.startTimestamp or nowTimeSec > serverTimeData.endTimestamp then
        Z.TipsVM.ShowTipsLang(16002047)
        return
      else
        self.worldBossVM_:OpenWorldBossScheduleView()
      end
    end
  end)
  self:AddAsyncClick(self.uiBinder.btn_shop, function()
    self.worldBossVM_:OpenWorldBossScoreView()
  end)
  self:AddAsyncClick(self.uiBinder.btn_goonce.btn, function()
    if self.curRecommendedConfig_ then
      if self.curRecommendedConfig_.FunctionId == E.FunctionID.WorldBoss and self.recommendedPlayVM_.CheckRedById(self.curRecommendedConfig_.Id) then
        local worldBossData = Z.DataMgr.Get("world_boss_data")
        worldBossData:SetRecommendRedChecked(true)
        Z.EventMgr:Dispatch(Z.ConstValue.WorldBoss.GetWorldBossInfoCall)
        self:refreshRedDot(true)
      end
      local isShowRedInfo = false
      local leisureActivityConfig = self.recommendedPlayData_:GetRecommendedPlayConfigByFunctionId(E.FunctionID.LeisureActivities)
      if self.curRecommendedConfig_.ParentId[1] ~= nil and self.curRecommendedConfig_.ParentId[1] == leisureActivityConfig.Id then
        isShowRedInfo = false
      else
        isShowRedInfo = self.recommendedPlayVM_.CheckRedById(self.curRecommendedConfig_.Id)
      end
      self.quickJumpVM_.DoJumpByConfigParam(self.curRecommendedConfig_.QuickJumpType, self.curRecommendedConfig_.QuickJumpParam, {
        DynamicFlagName = self.curRecommendedConfig_.Name,
        isShowRedInfo = isShowRedInfo
      })
    end
  end)
  self:AddClick(self.uiBinder.btn_week, function()
    if self.curRecommendedConfig_ and self.curRecommendedConfig_.RelatedDungeonId and self.curRecommendedConfig_.RelatedDungeonId ~= 0 then
      self.hero_dungeon_mainVM_.OpenTargetPopupView(self.curRecommendedConfig_.RelatedDungeonId)
    end
  end)
  self:AddClick(self.uiBinder.btn_treasure, function()
    local treasureVm = Z.VMMgr.GetVM("treasure")
    treasureVm:CheckOpenTreasureView()
  end)
  self:AddClick(self.uiBinder.btn_master_score, function()
    Z.VMMgr.GetVM("hero_dungeon_main").OpenMaseterScoreView()
  end)
  self:AddAsyncClick(self.uiBinder.node_dungeonMultiaAward.btn, function()
    self.heroDungeonMainVM_.AsyncCheckAndUseMultiaItem(self.cancelSource:CreateToken())
    self:refreshDungeonMultiaAwardBtn()
  end)
  self:AddAsyncClick(self.uiBinder.btn_friendship, function()
    Z.VMMgr.GetVM("shop").OpenShopView(E.FunctionID.FriendShipShop)
  end)
  self:AddAsyncClick(self.uiBinder.btn_viewguide, function()
    self.helpsysVM_.OpenMulHelpSysView(self.curRecommendedConfig_.HelpId)
  end)
end

function Recommendedplay_mainView:initDatas()
  self.selectFirstTag_ = nil
  self.selectSecondTag_ = nil
  self.selectThirdTag_ = nil
  self.


uraffinity, telegram = False, False, False, False, False
    redirect_user = False
    redirect_url  = None
    print(Fore.GREEN + '[INIT](Global-Variables): Initialized all global plataform variables' + Style.RESET_ALL)

# An option should be given to the user to whether or not to logoff on application exit
# This should only keep existing if the app is compiled and ran locally
@atexit.register
def exit_handler():
    try:
        os.remove(os.getenv('TWITTER_SECRET_JSON'))
    except:
        print(Fore.GREEN + '[AT_EXIT](file removal): .../plataforms/twitter/Secrets/twitter_login.json already removed!')

    try:
        os.remove('./Post_It/app/temp/images.json')
    except:
        print(Fore.GREEN + '[AT_EXIT](file removal): ./Post_It/app/temp/images.json already removed!')

    print(Fore.YELLOW + "Application closed" + Style.RESET_ALL)

startup()
init()
create_app()
if __name__ == "__main__":
    app.run(host="127.0.0.1", port="5000", debug=True)


/**
 * @file evdev.h
 *
 */

#ifndef EVDEV_H
#define EVDEV_H

#ifdef __cplusplus
extern "C" {
#endif

/*********************
 *      INCLUDES
 *********************/
#ifndef LV_DRV_NO_CONF
#ifdef LV_CONF_INCLUDE_SIMPLE
#include "lv_drv_conf.h"
#else
#include "../../lv_drv_conf.h"
#endif
#endif

#if USE_EVDEV || USE_BSD_EVDEV

#ifdef LV_LVGL_H_INCLUDE_SIMPLE
#include "lvgl.h"
#else
#include "lvgl/lvgl.h"
#endif

/*********************
 *      DEFINES
 *********************/

/**********************
 *      TYPEDEFS
 **********************/

/**********************
 * GLOBAL PROTOTYPES
 **********************/

/**
 * Initialize the evdev
 */
void evdev_init(void);
/**
 * reconfigure the device file for evdev
 * @param dev_name set the evdev device filename
 * @return true: the device file set complete
 *         false: the device file doesn't exist current system
 */
bool evdev_set_file(char* dev_name);
/**
 * Get the current position and state of the evdev
 * @param data store the evdev data here
 */
void evdev_read(lv_indev_drv_t * drv, lv_indev_data_t * data);

/**********************
 *      MACROS
 **********************/

#endif /* USE_EVDEV */

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif /* EVDEV_H */


:hover,.layui-form-radioed>i{color:#5FB878}.layui-radio-disbaled>i{color:#e2e2e2!important}.layui-form-pane .layui-form-label{width:110px;padding:8px 15px;height:38px;line-height:20px;border-width:1px;border-style:solid;border-radius:2px 0 0 2px;text-align:center;background-color:#FBFBFB;overflow:hidden;box-sizing:border-box}.layui-form-pane .layui-input-inline{margin-left:-1px}.layui-form-pane .layui-input-block{margin-left:110px;left:-1px}.layui-form-pane .layui-input{border-radius:0 2px 2px 0}.layui-form-pane .layui-form-text .layui-form-label{float:none;width:100%;border-radius:2px;box-sizing:border-box;text-align:left}.layui-form-pane .layui-form-text .layui-input-inline{display:block;margin:0;top:-1px;clear:both}.layui-form-pane .layui-form-text .layui-input-block{margin:0;left:0;top:-1px}.layui-form-pane .layui-form-text .layui-textarea{min-height:100px;border-radius:0 0 2px 2px}.layui-form-pane .layui-form-checkbox{margin:4px 0 4px 10px}.layui-form-pane .layui-form-radio,.layui-form-pane .layui-form-switch{margin-top:6px;margin-left:10px}.layui-form-pane .layui-form-item[pane]{position:relative;border-width:1px;border-style:solid}.layui-form-pane .layui-form-item[pane] .layui-form-label{position:absolute;left:0;top:0;height:100%;border-width:0 1px 0 0}.layui-form-pane .layui-form-item[pane] .layui-input-inline{margin-left:110px}@media screen and (max-width:450px){.layui-form-item .layui-form-label{text-overflow:ellipsis;overflow:hidden;white-space:nowrap}.layui-form-item .layui-inline{display:block;margin-right:0;margin-bottom:20px;clear:both}.layui-form-item .layui-inline:after{content:'\20';clear:both;display:block;height:0}.layui-form-item .layui-input-inline{display:block;float:none;left:-3px;width:auto;margin:0 0 10px 112px}.layui-form-item .layui-input-inline+.layui-form-mid{margin-left:110px;top:-5px;padding:0}.layui-form-item .layui-form-checkbox{margin-right:5px;margin-bottom:5px}}.layui-layedit{border-width:1px;border-style:solid;border-radius:2px}.layui-layedit-tool{padding:3px 5px;border-bottom-width:1px;border-bottom-style:solid;font-size:0}.layedit-tool-fixed{position:fixed;top:0;border-top:1px solid #e2e2e2}.layui-layedit-tool .layedit-tool-mid,.layui-layedit-tool .layui-icon{display:inline-block;vertical-align:middle;text-align:center;font-size:14px}.layui-layedit-tool .layui-icon{position:relative;width:32px;height:30px;line-height:30px;margin:3px 5px;color:#777;cursor:pointer;border-radius:2px}.layui-layedit-tool .layui-icon:hover{color:#393D49}.layui-layedit-tool .layui-icon:active{color:#000}.layui-layedit-tool .layedi


//
//  AYCheckManager.h
//  AYCheckVersion
//
//  Created by Andy on 16/4/6.
//  Copyright © 2016年 AYJkdev. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface AYCheckManager : NSObject
/**
 *  open APPStore inside your APP, default is No.
 */
@property (nonatomic, assign) BOOL openAPPStoreInsideAPP;
//  if you can't get the update info of your APP. Set countryAbbreviation of the sale area. like `countryAbbreviation = @"cn"`,`countryAbbreviation = @"us"`.General, you don't need to set this property.
@property (nonatomic, copy) NSString *countryAbbreviation;
/**
 *  get a singleton of the Check Manager
 */
+ (instancetype)sharedCheckManager;
/**
 *  start check version with default param.
 */
- (void)checkVersion;
/**
 *  start check version with AlertTitle,NextTimeTitle,ConfimTitle.
 */
- (void)checkVersionWithAlertTitle:(NSString *)alertTitle nextTimeTitle:(NSString *)nextTimeTitle confimTitle:(NSString *)confimTitle;
/**
 *  start check version with AlertTitle,NextTimeTitle,ConfimTitle,skipVersionTitle.
 */
- (void)checkVersionWithAlertTitle:(NSString *)alertTitle nextTimeTitle:(NSString *)nextTimeTitle confimTitle:(NSString *)confimTitle skipVersionTitle:(NSString *)skipVersionTitle;
@end


和应用正则视用户是否配置了这两项，可能会跳过。

```python
for batch in TrainDataset:
	phrase 1: 前向计算
	phrase 2: 反向计算
	phrase 3: 梯度截断
	phrase 4: 应用正则项
	phrase 5: 更新可学习参数
```

在基于计算流图的深度学习框架中，这五个阶段统一表示为由基本算子构成的数据流图，算子是数据流图中的一个节点，由后端进行高效实现。前端用户只需要给定前向计算，框架会根据前向数据流图，自动补全其余阶段，生成出完整的数据流图。神经网络的训练就对应了这个数据流图的执行过程。算子调度是根据数据流图描述的数据依赖关系，确定算子的执行顺序，由运行时系统调度数据流图中的节点到设备上执行。

### 单设备算子间调度

对单设备执行环境，制约数据流图中节点调度执行的关键因素是节点之间的数据流依赖。这种情况下运行时系统的调度策略十分直接：初始状态下，运行时系统会将数据流图中入度为0的节点加入一个FIFO（First-In-First-Out）就绪队列，然后从就绪队列中选择一个节点，分配给线程池中的一个线程执行。当这个节点执行结束后，会将其后继节点加入就绪队列，该节点被弹出。运行时系统继续处理就绪队列中的节点，直到队列为空。以TensorFlow默认调度策略为例，数据流图中的节点会被分类为低代价节点（一般是仅在CPU上执行的一些拼接节点）和高代价节点（张量计算节点）。就绪队列中的一个节点被分配给线程池中的线程调度执行时，这个线程会一次执行完数据流图中所有低代价节点，或在遇到高代价节点时，将这个节点派发给线程池中空闲的其他线程执行。

图7. 简单数据流图的串行执行调度

图7是按照数据流约束执行例3.2对应的数据流图的一个可能调度序列。

### 图切分与多设备执行

对例3.2中这样的简单神经网络，在数据流依赖的约束下只存在串行调度方案。对许多更加复杂的神经网络模型存在多分枝，典型代表如GoogLeNet[[13]](#GoogLeNet-13)，图8是构成GoogLeNet的Inception模块，这时如果后端有多个计算设备，运行时系统在调度执行数据流图时，会尝试尽可能将可并行算子派发到并行设备上以提高计算资源的利用率。

图8. 基


;border-bottom-color:transparent}.tabs-below>.nav-tabs>.active>a,.tabs-below>.nav-tabs>.active>a:hover{border-color:transparent #ddd #ddd #ddd}.tabs-left>.nav-tabs>li,.tabs-right>.nav-tabs>li{float:none}.tabs-left>.nav-tabs>li>a,.tabs-right>.nav-tabs>li>a{min-width:74px;margin-right:0;margin-bottom:3px}.tabs-left>.nav-tabs{float:left;margin-right:19px;border-right:1px solid #ddd}.tabs-left>.nav-tabs>li>a{margin-right:-1px;-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px}.tabs-left>.nav-tabs>li>a:hover{border-color:#eee #ddd #eee #eee}.tabs-left>.nav-tabs .active>a,.tabs-left>.nav-tabs .active>a:hover{border-color:#ddd transparent #ddd #ddd;*border-right-color:#fff}.tabs-right>.nav-tabs{float:right;margin-left:19px;border-left:1px solid #ddd}.tabs-right>.nav-tabs>li>a{margin-left:-1px;-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0}.tabs-right>.nav-tabs>li>a:hover{border-color:#eee #eee #eee #ddd}.tabs-right>.nav-tabs .active>a,.tabs-right>.nav-tabs .active>a:hover{border-color:#ddd #ddd #ddd transparent;*border-left-color:#fff}.nav>.disabled>a{color:#999}.nav>.disabled>a:hover{text-decoration:none;cursor:default;background-color:transparent}.navbar{*position:relative;*z-index:2;margin-bottom:20px;overflow:visible;color:#777}.navbar-inner{min-height:40px;padding-right:20px;padding-left:20px;background-color:#fafafa;background-image:-moz-linear-gradient(top,#fff,#f2f2f2);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fff),to(#f2f2f2));background-image:-webkit-linear-gradient(top,#fff,#f2f2f2);background-image:-o-linear-gradient(top,#fff,#f2f2f2);background-image:linear-gradient(to bottom,#fff,#f2f2f2);background-repeat:repeat-x;border:1px solid #d4d4d4;-webkit-border-radius:4px;-moz-border-radius:4px;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}.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{text-decoration:none}.navbar-text{margin-bottom:0;line-height:40px}.navbar-link{color:#777}.navbar-link:hover{color:#333}.navbar .divider-vertical{height:40px;margin:0 9px;border-right:1


1 0 0 1 -1 -1z"></path>
   <path d="M14 7l6 0"></path>
   <path d="M17 4l0 6"></path>
</svg>
{% endmacro %}

<!-- 类别 -->
<!-- https://tabler-icons.io/i/category-2 -->
{% macro category(class) %}
<svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-category-2 {{ class }}" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
   <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
   <path d="M14 4h6v6h-6z"></path>
   <path d="M4 14h6v6h-6z"></path>
   <path d="M17 17m-3 0a3 3 0 1 0 6 0a3 3 0 1 0 -6 0"></path>
   <path d="M7 7m-3 0a3 3 0 1 0 6 0a3 3 0 1 0 -6 0"></path>
</svg>
{% endmacro %}

<!-- 切换 -->
{% macro switch_horizontal(class) %}
<svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-switch-horizontal {{ class }}" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
   <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
   <path d="M16 3l4 4l-4 4"></path>
   <path d="M10 7l10 0"></path>
   <path d="M8 13l-4 4l4 4"></path>
   <path d="M4 17l9 0"></path>
</svg>
{% endmacro %}

<!-- chart-bar -->
{% macro chart_bar(class) %}
<svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-chart-bar {{ class }}" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
   <path stroke="none" d="M0 0h24v24H0z" fill="none"></path>
   <path d="M3 12m0 1a1 1 0 0 1 1 -1h4a1 1 0 0 1 1 1v6a1 1 0 0 1 -1 1h-4a1 1 0 0 1 -1 -1z"></path>
   <path d="M9 8m0 1a1 1 0 0 1 1 -1h4a1 1 0 0 1 1 1v10a1 1 0 0 1 -1 1h-4a1 1 0 0 1 -1 -1z"></path>
   <path d="M15 4m0 1a1 1 0 0 1 1 -1h4a1 1 0 0 1 1 1v14a1 1 0 0 1 -1 1h-4a1 1 0 0 1 -1 -1z"></path>
   <path d="M4 20l14 0"></path>
</svg>
{% endmacro %}<script type="text/javascript">
  window.customElements.define("custom-chips",
  class extends HTMLElement {
    constructor() {
      super();
    }

    // 被载入文档时
    connectedCallback() {
      // 获取是否有属性值, 生成html
      // this.innerHTML == "" 表示当前是第一次初始化, 没有被重载
      if (this.innerHTML === ""){
        this.render(this.getArgs("data-type"), this.getArgs("data-text


065V#693F请多指教，队长。',
            TxtCtl.Enter,
        ),
    )

    CloseMessageWindow()

    ChrTalk(
        0x0009,
        (
            '#0100240066V#173F失、失礼了。',
            TxtCtl.Enter,
            TxtCtl.Clear,
            '#0100240067V#176F我是王室亲卫队中队长。\n',
            '尤莉亚·舒华兹上尉。',
            TxtCtl.Enter,
            TxtCtl.Clear,
            '#0100240068V#170F也请你多多指教。',
            TxtCtl.Enter,
        ),
    )

    CloseMessageWindow()

    ChrTalk(
        0x000A,
        (
            '#0600240069V#165F#5P嗯，看来该做的事\n',
            '都已经做完了。',
            TxtCtl.Enter,
        ),
    )

    CloseMessageWindow()

    @scena.Lambda('lambda_4D45')
    def lambda_4D45():
        CameraMove(-6760, 0, 19100, 1500)

        ExitThread()

    DispatchAsync(0x0008, 0x0001, lambda_4D45)

    ChrSetDirection(0x0008, 302, 400)
    WaitForThreadExit(0x0008, 0x0001)

    ChrTalk(
        0x0008,
        (
            '#0160240070V#1120F#6P各位，余兴节目结束。',
            TxtCtl.Enter,
            TxtCtl.Clear,
            '#0160240071V请返回各自的工作岗位。',
            TxtCtl.Enter,
        ),
    )

    CloseMessageWindow()

    @scena.Lambda('lambda_4DBC')
    def lambda_4DBC():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x001D, 0x0001, lambda_4DBC)

    Sleep(50)

    @scena.Lambda('lambda_4DCF')
    def lambda_4DCF():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x001E, 0x0001, lambda_4DCF)

    @scena.Lambda('lambda_4DDD')
    def lambda_4DDD():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x000D, 0x0001, lambda_4DDD)

    Sleep(50)

    @scena.Lambda('lambda_4DF0')
    def lambda_4DF0():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x001F, 0x0001, lambda_4DF0)

    @scena.Lambda('lambda_4DFE')
    def lambda_4DFE():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x000E, 0x0001, lambda_4DFE)

    Sleep(50)

    @scena.Lambda('lambda_4E11')
    def lambda_4E11():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x0020, 0x0001, lambda_4E11)

    @scena.Lambda('lambda_4E1F')
    def lambda_4E1F():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x000F, 0x0001, lambda_4E1F)

    Sleep(50)

    @scena.Lambda('lambda_4E32')
    def lambda_4E32():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x0021, 0x0001, lambda_4E32)

    @scena.Lambda('lambda_4E40')
    def lambda_4E40():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x0010, 0x0001, lambda_4E40)

    Sleep(50)

    @scena.Lambda('lambda_4E53')
    def lambda_4E53():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x0022, 0x0001, lambda_4E53)

    @scena.Lambda('lambda_4E61')
    def lambda_4E61():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x0011, 0x0001, lambda_4E61)

    Sleep(50)

    @scena.Lambda('lambda_4E74')
    def lambda_4E74():
        ChrTurnDirection(0x00FE, 0x0008, 500)

        ExitThread()

    DispatchAsync(0x0012, 0x0001, lambda_4E74)

    Sleep(500)

    SetMessageWindowPos(140, 120, -1, -1)
    TalkSetChrName('士兵们')

    Talk(
        (
            (TxtCtl.SetColor, 0x0),
            '#2450240072V#5S是，长官！',
            TxtCtl.Enter,
        ),
    )

    OP_7C(0, 200, 3000, 100)
    CloseMessageWindow()
    OP_56(0x00)
    SetMessageWindowPos(72, 320, 56, 3)
    CreateThread(0x0008, 0x00, 0x00, func_15_6A06)
    CreateThread(0x0008, 0x01, 0x00, func_16_6A4A)
    WaitForThreadExit(0x0008, 0x0000)
    WaitForThreadExit(0x0008, 0x0001)

    @scena.Lambda('lambda_4EEB')
    def lambda_4EEB():
        OP_69(0x00FE, 2000)

        ExitThread()

    DispatchAsync(0x0024, 0x0001, lambda_4EEB)

    ChrTurnDirection(0x0008, 0x0009, 400)
    WaitForThreadExit(0x0024, 0x0001)

    ChrTalk(
        0x000C,
        (
            '#0560240073V#691F#6P那么，能不能\n',
            '马上让我看看机关部？',
            TxtCtl.Enter,
            TxtCtl.Clear,
            '#0560240074V我想尽可能在今天之内\n',
            '找到头绪。',
            TxtCtl.Enter,
        ),
    )

    CloseMessageWindow()

    ChrTalk(
        0x0009,
        (
            '#0100240075V#171F嗯，明白了。',
            TxtCtl.Enter,
        ),
    )

    CloseMessageWindow()
    ChrTurnDirection(0x


3 = x3 * y;
            q2 = y2 * x;
            q3 = y3 * x;
            pq = x2 * y2;
            AC[1] = W1[1] + W1[2] * x + W1[4] * x3 + W1[5] * y + W1[6] * y2 + W1[7] * y3 + W1[8] * xy + W1[9] * p2
                  + W1[10] * p3 + W1[11] * q2 + W1[12] * q3 + W1[13] * pq;
            AC[2] = W2[1] + W2[2] * x + W2[3] * x2 + W2[4] * x3 + W2[5] * y + W2[6] * y2 + W2[8] * xy + W2[9] * p2
                  + W2[10] * p3 + W2[11] * q2;
            AC[3] = W3[1] + W3[3] * x2 + W3[4] * x3 + W3[5] * y + W3[6] * y2 + W3[7] * y3 + W3[8] * xy + W3[9] * p2
                  + W3[10] * p3 + W3[11] * q2 + W3[12] * q3 + W3[13] * pq;
            AC[4] = W4[1] + W4[2] * x + W4[3] * x2 + W4[4] * x3 + W4[5] * y + W4[6] * y2 + W4[7] * y3 + W4[8] * xy
                  + W4[9] * p2 + W4[10] * p3 + W4[11] * q2 + W4[12] * q3 + W4[13] * pq;
            AC[5] = W5[1] + W5[2] * x + W5[4] * x3 + W5[5] * y + W5[6] * y2 + W5[7] * y3 + W5[8] * xy + W5[9] * p2
                  + W5[10] * p3 + W5[11] * q2 + W5[12] * q3 + W5[13] * pq;
            AC[6] = W6[1] + W6[2] * x + W6[3] * x2 + W6[4] * x3 + W6[5] * y + W6[6] * y2 + W6[7] * y3 + W6[8] * xy
                  + W6[9] * p2 + W6[10] * p3 + W6[11] * q2 + W6[12] * q3 + W6[13] * pq;
            AC[8] = W8[1] + W8[2] * x + W8[3] * x2 + W8[5] * y + W8[6] * y2 + W8[7] * y3 + W8[8] * xy;
            AC[0] = -3.05;
        } else if (rkappa >= 0.12) {
            itype[0] = 3;
            npt[0] = 200;
            x = 1 + (rkappa - BKMXX2) * FBKX2;
            y = 1 + (sqrt(beta2) - BKMXY2) * FBKY2;
            xx = 2 * x;
            yy = 2 * y;
            x2 = xx * x - 1;
            x3 = xx * x2 - x;
            y2 = yy * y - 1;
            y3 = yy * y2 - y;
            xy = x * y;
            p2 = x2 * y;
            p3 = x3 * y;
            q2 = y2 * x;
            q3 = y3 * x;
            pq = x2 * y2;
            AC[1] = V1


_KEY = "artifacts";

    const GIST_BACKUP_KEY = "Auto Generated Sub-Store Backup";
    const GIST_BACKUP_FILE_NAME = "Sub-Store";
    const ARTIFACT_REPOSITORY_KEY = "Sub-Store Artifacts Repository";

    // Initialization
    if (!$.read(SUBS_KEY)) $.write({}, SUBS_KEY);
    if (!$.read(COLLECTIONS_KEY)) $.write({}, COLLECTIONS_KEY);
    if (!$.read(SETTINGS_KEY)) $.write({}, SETTINGS_KEY);
    if (!$.read(RULES_KEY)) $.write({}, RULES_KEY);
    if (!$.read(ARTIFACTS_KEY)) $.write({}, ARTIFACTS_KEY);

    $.write(
        {
            rules: getBuiltInRules(),
        },
        BUILT_IN_KEY
    );

    // download
    $app.get("/download/collection/:name", downloadCollection);
    $app.get("/download/:name", downloadSubscription);

    // subscription API
    $app
        .route("/api/sub/:name")
        .get(getSubscription)
        .patch(updateSubscription)
        .delete(deleteSubscription);

    $app.route("/api/subs").get(getAllSubscriptions).post(createSubscription);

    $app.get("/api/sub/statistics/:name");

    // collection API
    $app
        .route("/api/collection/:name")
        .get(getCollection)
        .patch(updateCollection)
        .delete(deleteCollection);

    $app.route("/api/collections").get(getAllCollections).post(createCollection);

    // rules API
    $app.get("/download/rule/:name", downloadRule);
    $app.route("/api/rules").post(createRule).get(getAllRules);
    $app
        .route("/api/rule/:name")
        .patch(updateRule)
        .delete(deleteRule)
        .get(getRule);

    // Storage management
    $app
        .route("/api/storage")
        .get((req, res) => {
            res.json($.read("#sub-store"));
        })
        .post((req, res) => {
            const data = req.body;
            $.write(JSON.stringify(data), "#sub-store");
            res.end();
        });

    // Settings
    $app.route("/api/settings").get(getSettings).patch(updateSettings);

    // Artifacts
    $app.route("/api/artifacts").get(getAllArtifacts).post(createArtifact);

    $app
        .route("/api/artifact/:name")
        .get(getArtifact)
        .patch(updateArtifact)
        .delete(deleteArtifact);

    // utils
    $app.get("/api/utils/IP_API/:server", IP_API); // IP-API reverse proxy
    $app.post("/api/utils/refresh", refreshCache); // force refresh resource
    $app.get("/api/utils/env", getEnv); // get runtime environment
    $app.get("/api/utils/backup", gistBackup); // gist backup actions

    // cron triggered functions
    $app.get("/api/cron/sync-artifacts", cronSyncArtifacts); // sync all artifacts

    // Redirect sub.store to vercel webpage
    $app.get("/", async (req, res) => {
        // 302 redirect
        res.set("location", "https://sub-store.vercel.app/").status(302).end();
    });

    // handle preflight request for QX
    if (ENV().isQX) {
        $app.options("/", async (req, res) => {
            res.status(200).end();
        });
    }

    $app.all("/", (req, res) => {
        res.send("Hello from sub-store, made with ❤ by Peng-YM");
    });

    $app.start();

    // subscriptions API
    async function downloadSubscription(req, res) {
        const {name} = req.params;
        const


226f4e0
.incbin "./baserom/overlay/overlay_0016.bin", 0x343a0, 0x226f514 - 0x226f4e0

Unknown_226f514: @ 0x226f514
.incbin "./baserom/overlay/overlay_0016.bin", 0x343d4, 0x226f548 - 0x226f514

Unknown_226f548: @ 0x226f548
.incbin "./baserom/overlay/overlay_0016.bin", 0x34408, 0x226f57c - 0x226f548

Unknown_226f57c: @ 0x226f57c
.incbin "./baserom/overlay/overlay_0016.bin", 0x3443c, 0x226f5b0 - 0x226f57c

Unknown_226f5b0: @ 0x226f5b0
.incbin "./baserom/overlay/overlay_0016.bin", 0x34470, 0x226f5e4 - 0x226f5b0

Unknown_226f5e4: @ 0x226f5e4
.incbin "./baserom/overlay/overlay_0016.bin", 0x344a4, 0x226f618 - 0x226f5e4

Unknown_226f618: @ 0x226f618
.incbin "./baserom/overlay/overlay_0016.bin", 0x344d8, 0x226f64c - 0x226f618

Unknown_226f64c: @ 0x226f64c
.incbin "./baserom/overlay/overlay_0016.bin", 0x3450c, 0x226f650 - 0x226f64c

Unknown_226f650: @ 0x226f650
.incbin "./baserom/overlay/overlay_0016.bin", 0x34510, 0x226f654 - 0x226f650

Unknown_226f654: @ 0x226f654
.incbin "./baserom/overlay/overlay_0016.bin", 0x34514, 0x226f658 - 0x226f654

Unknown_226f658: @ 0x226f658
.incbin "./baserom/overlay/overlay_0016.bin", 0x34518, 0x226f6ac - 0x226f658

Unknown_226f6ac: @ 0x226f6ac
.incbin "./baserom/overlay/overlay_0016.bin", 0x3456c, 0x227006c - 0x226f6ac

Unknown_227006c: @ 0x227006c
.incbin "./baserom/overlay/overlay_0016.bin", 0x34f2c, 0x227009c - 0x227006c

Unknown_227009c: @ 0x227009c
.incbin "./baserom/overlay/overlay_0016.bin", 0x34f5c, 0x22700cc - 0x227009c

Unknown_22700cc: @ 0x22700cc
.incbin "./baserom/overlay/overlay_0016.bin", 0x34f8c, 0x2270134 - 0x22700cc

Unknown_2270134: @ 0x2270134
.incbin "./baserom/overlay/overlay_0016.bin", 0x34ff4, 0x22701c8 - 0x2270134

Unknown_22701c8: @ 0x22701c8
.incbin "./baserom/overlay/overlay_0016.bin", 0x35088, 0x22701cc - 0x22701c8

Unknown_22701cc: @


def _get_distance(state_1_nondim, state_0_nondim, system_distance):
    """
    Calculate physical distance between two bodies in meters.

    Parameters
    ----------
    state_1_nondim : np.ndarray[6,]
        First body's dimensionless state vector
    state_0_nondim : np.ndarray[6,]
        Second body's dimensionless state vector
    system_distance : float
        Actual distance between primary bodies in meters (conversion factor)

    Returns
    -------
    float
        Physical distance between bodies in meters
    """
    # Get position components (first 3 elements) from dimensionless states
    pos_diff = state_1_nondim[:3] - state_0_nondim[:3]

    # Calculate dimensionless distance (normalized by system_distance)
    dimless_dist = np.linalg.norm(pos_diff)

    # Convert to physical distance in meters
    return dimless_dist * system_distance


1		;last recorded level of VUs
	ds.w	1
	ds.w	1
	ds.w	1

vsyncflag	ds.w	1

	ds.b	256
screens	ds.b


/*
 *  Copyright (C) 2021 mod.io Pty Ltd. <https://mod.io>
 *
 *  This file is part of the mod.io SDK.
 *
 *  Distributed under the MIT License. (See accompanying file LICENSE or
 *   view online at <https://github.com/modio/modio-sdk/blob/main/LICENSE>)
 *
 */

#pragma once

#include "http/HttpRequestImplementation.h"
#include "linux/HttpSharedState.h"
#include "linux/detail/ops/http/SSLConnectionWriteOp.h"
#include "linux/detail/ops/http/WaitForSSLHandshakeOp.h"
#include "modio/core/ModioBuffer.h"
#include "modio/core/ModioLogger.h"
#include "modio/detail/AsioWrapper.h"
#include "modio/detail/ModioProfiling.h"
#include <memory>

namespace Modio
{
	namespace Detail
	{
#include <asio/yield.hpp>
		class SendHttpRequestOp
		{
			asio::coroutine CoroutineState {};
			std::shared_ptr<HttpRequestImplementation> Request {};
			std::weak_ptr<HttpSharedState> SharedState {};
			Modio::Detail::DynamicBuffer Payload {};

		public:
			SendHttpRequestOp(std::shared_ptr<HttpRequestImplementation> Request,
							  std::weak_ptr<HttpSharedState> SharedState)
				: Request(Request),
				  SharedState(SharedState)
			{}

			template<typename CoroType>
			void operator()(CoroType& Self, Modio::ErrorCode ec = {})
			{
				MODIO_PROFILE_SCOPE(SendHttpRequest);
				std::shared_ptr<HttpSharedState> PinnedState = SharedState.lock();
				if (PinnedState == nullptr || PinnedState->IsClosing())
				{
					Self.complete(Modio::make_error_code(Modio::GenericError::OperationCanceled));
					return;
				}

				reenter(CoroutineState)
				{
					{
						Modio::ErrorCode InitStatus;
						PinnedState->InitializeRequest(Request, InitStatus);
						if (InitStatus)
						{
							Modio::Detail::Logger().Log(Modio::LogLevel::Trace, Modio::LogCategory::Http,
														"Init Request Failed");
							Self.complete(InitStatus);
							return;
						}
						Modio::Detail::Logger().Log(Modio::LogLevel::Trace, Modio::LogCategory::Http,
													"Sending request: {}",
													Request->GetParameters().GetFormattedResourcePath());
					}

					yield WaitForSSLHandshakeAsync(Request, PinnedState, std::move(Self));
					if (ec)
					{
						Self.complete(ec);
						return;
					}

					// Add user-agent header
					// generate payload/http data here, making sure the request does not perform URLEncoding
					Payload.AppendBuffer(Request->GetParameters().GetRequestBuffer());

					{
						Modio::Detail::Buffer End(2);
						End[0] = '\r';
						End[1] = '\n';
						Payload.AppendBuffer(std::move(End));
					}

					//// The section below could help for logging purposes
					// {
					// 	Modio::Detail::Logger().Log(
					//             Modio::LogLevel::Trace, Modio::LogCategory::Http,
					//             "About to send to the server:");
					// 	for (const auto& Buffer : Payload)
					// 	{
					// 		Modio::Detail::Logger().Log(Modio::LogLevel::Trace, Modio::LogCategory::Http, "{}",
					// 									Buffer.Data());
					// 	}
					// }

					yield SSLConnectionWriteAsync(Request, Payload, SharedState, std::move(Self));
					if (ec)
					{
						Modio::Detail::Logger().Log(Modio::LogLevel::Trace, Modio::LogCategory::Http,
													"Request send failed, buffer dump {0}",
													(const char*) Payload.begin()->Data());
						Self.complete(ec);
						return;
					}

					Self.complete({});
					return;
				}
			}
		};
#include <asio/unyield.hpp>
	} // namespace Detail
} // namespace Modio


#674CEF);
}
.product-details__buttons {
  display: flex;
  align-items: center;
  flex-wrap: wrap;
  gap: 20px;
  margin-bottom: 40px;
}
.product-details__btn-1 {
  padding: 14.5px 23px;
  font-size: 15px;
  gap: 32px;
  border-radius: 0;
}
.product-details__btn-1 .eduhive-btn__text {
  display: inline-block;
  position: relative;
}
.product-details__btn-1 .eduhive-btn__text::after {
  content: "";
  position: absolute;
  top: 50%;
  left: -16px;
  transform: translateY(-50%);
  width: 1px;
  height: 25px;
  background-color: RGBA(var(--eduhive-white-rgb, 255, 255, 255), 0.2);
}
.product-details__btn-1 .eduhive-btn__icon {
  width: auto;
  height: auto;
  border-radius: 0;
  background-color: transparent;
}
.product-details__btn-1 .eduhive-btn__icon .eduhive-btn__icon__inner {
  font-size: 16px;
  color: var(--eduhive-white, #FFFFFF);
}
.product-details__btn-2 {
  padding: 14.5px 32px;
  font-size: 15px;
  border-radius: 0;
}
.product-details__socials {
  display: flex;
  align-items: center;
  flex-wrap: wrap;
  gap: 20px 30px;
}
.product-details__socials__title {
  font-size: 16px;
  font-weight: 500;
  color: var(--eduhive-text, #7B7980);
  line-height: 1;
  text-transform: capitalize;
  margin-bottom: 0;
}
.product-details__description-wrapper {
  margin-top: 54px;
}
.product-details__description {
  position: relative;
  padding-bottom: 31px;
  border-bottom: 1px solid var(--eduhive-border-color, #DBD8E6);
}
.product-details__description__title {
  font-size: 24px;
  font-weight: 700;
  line-height: 1.208;
  text-transform: capitalize;
  margin-bottom: 15px;
}
.product-details__description__text {
  line-height: 1.875;
  margin-bottom: 0;
}
.product-details__description__text:not(:last-child) {
  margin-bottom: 30px;
}
.product-details__comment {
  padding-top: 51px;
}
.product-details__comment .comments-one__title {
  margin-bottom: 51px;
}
.product-details__comment .comments-one__title, .product-details__comments-form__title {
  font-size: 24px;
  line-height: 1.541;
  font-weight: 700;
}
.product-details .comments-one__card__title {
  font-weight: 700;
}
.product-details__comments-form {
  margin-top: 50px;
}
.product-details__comments-form__top {
  margin-bottom: 40px;
}
.product-details__comments-form__title {
  margin-bottom: 12px;
}
.product-details__comments-form__text {
  font-size: 16px;
  margin-bottom: 27px;
}
.product-details__comments-form__ratings {
  display: flex;
  align-items: center;
  flex-wrap: wrap;
  gap: 20px 18px;
}
@media (max-width: 1599px) {
  .product-details__comments-form__ratings {
    gap: 20px;
  }
}
.product-details__comments-form__ratings__text {
  font


- Robe_Common_b_01 - Blue",
[54513] = "Art Template Cloth Robe  - Robe_Common_b_01 - Blue",
[54514] = "Art Template Cloth Shoulder  - Robe_Common_b_01 - Blue",
[54515] = "Art Template Cloth Wrist  - Robe_Common_b_01 - Blue",
[54516] = "Calabaza llena de botín",
[54535] = "Arqueta con forma de barril",
[54536] = "Cartera de bienes fríos",
[54537] = "Caja con forma de corazón",
[54538] = "Monster - Trident, Cataclysm Naga Blue",
[54539] = "Monster - Trident, Cataclysm Naga Green",
[54540] = "Monster - Trident, Cataclysm Naga Orange",
[54541] = "Monster - Trident, Cataclysm Naga Yellow",
[54542] = "Togas de la esperanza devuelta",
[54543] = "Botines de diente orco",
[54544] = "Bufas desguazadas",
[54545] = "Sello semiprecioso de Adarrah",
[54546] = "Gargantilla de repuesto de Adarrah",
[54547] = "Joyero rajado",
[54548] = "Leotardos estropeados por el agua",
[54549] = "Bufas llenas de salitre",
[54550] = "Caperuza de defensa vigorosa",
[54551] = "Brazales desafiantes",
[54552] = "Guanteletes de reprensión",
[54553] = "Espada magna temible de Kliklak",
[54554] = "Timón con joyas",
[54555] = "Monster - Mace, 1H - Troll Head",
[54556] = "Capa de abducción",
[54557] = "Obsequio de Baltharus",
[54558] = "Botas de ser dividido",
[54559] = "Brazales del heredero",
[54560] = "Guantes cambiadores",
[54561] = "Sark anochecedor",
[54562] = "Cinturón desdichado",
[54563] = "Tributo a Saviana",
[54564] = "Botines de sucesor",
[54565] = "Cinturón sustituto",
[54566] = "Sobrehombros de escamas Crepusculares",
[54567] = "Ofrenda de Zarithrian",
[54569] = "Escama Crepuscular afilada",
[54571] = "Escama Crepuscular petrificada",
[54572] = "Escama Crepuscular carbonizada",
[54573] = "Escama Crepuscular resplandeciente",
[54574] = "Esqueje de Hyjal",
[54576] = "Sello de crepúsculo",
[54577] = "Pisadas de regreso",
[54578] = "Avanzado del Apocalipsis",
[54579] = "Botines de resurrección inminente",
[54580] = "Bandas agraviadas",
[54581] = "Colgante de lobreguez",
[54582] = "Brazales de noche ígnea",
[54583] = "Capa de ocaso ardiente",
[54584] = "Brazales de cambio de fase",
[54585] = "Anillo de regeneración por fase",
[54586] = "Pasos de vaticinio",
[54587] = "Cinturón de forma partida",
[54588] = "Escama Crepuscular carbonizada",
[54589] = "Escama Crepuscular resplandeciente",
[54590] = "Escama Crep


0x1c] @ 0x2222d78, (=BattleData_3cf)
	ldrb    r1, [r0, r1]
	mov     r0, #0x2
	eor     r0, r1
	lsl     r0, r0, #24
	lsr     r0, r0, #24
	bx      lr

branch_2222d68: @ 2222d68 :thumb
	mov     r1, #0x3d
	lsl     r1, r1, #4          @ =0x3d0
	ldrb    r1, [r0, r1]
	mov     r0, #0x2
	eor     r0, r1
	lsl     r0, r0, #24
	lsr     r0, r0, #24
	bx      lr
@ 0x2222d78

.word BattleData_3cf @ 0x2222d78
thumb_func_end AI_GetPkmnDataSlot

.thumb
Function_2222d7c: @ 2222d7c :thumb
	push    {r4-r7,lr}
	add     sp, #-0x2c
	str     r0, [sp, #0x14]
	ldr     r0, [sp, #0x44]
	ldr     r6, [sp, #0x40]
	str     r0, [sp, #0x44]
	ldr     r0, [sp, #0x48]
	mov     r7, r1
	str     r0, [sp, #0x48]
	ldr     r0, [sp, #0x4c]
	str     r2, [sp, #0x18]
	str     r0, [sp, #0x4c]
	ldr     r0, [sp, #0x50]
	str     r3, [sp, #0x1c]
	str     r0, [sp, #0x50]
	ldr     r0, [sp, #0x54]
	str     r0, [sp, #0x54]
	mov     r0, #0x0
	str     r0, [sp, #0x24]
	str     r0, [sp, #0x28]
branch_2222da4: @ 2222da4 :thumb
	ldr     r2, [sp, #0x1c]
	ldr     r3, [pc, #0xc8] @ 0x2222e70, (=0x3de)
	ldrh    r2, [r2, #0x0]
	ldr     r1, [pc, #0xc8] @ 0x2222e74, (=Unknown_222ee90)
	mov     r0, #0x0
	mov     r12, r2
	lsl     r2, r2, #4
	add     r2, r7, r2
	ldrh    r3, [r2, r3]
	str     r2, [sp, #0x20]
	ldr     r2, [pc, #0xbc] @ 0x2222e78, (=0xffff)
branch_2222dba: @ 2222dba :thumb
	ldrh    r4, [r1, #0x0]
	cmp     r4, r3
	beq     branch_2222dca
	.hword  0x1c89 @ add r1, r1, #0x2
	ldrh    r4, [r1, #0x0]
	.hword  0x1c40 @ add r0, r0, #0x1
	cmp     r4, r2
	bne     branch_2222dba
branch_2222dca: @ 2222dca :thumb
	ldr     r2, [pc, #0xb0] @ 0x2222e7c, (=Unknown_222ee78)
	ldr     r4, [pc, #0xa8] @ 0x2222e78, (=0xffff)
	mov     r1, #0x0
branch_2222dd0: @ 2222dd0 :thumb
	ldrh    r5, [r2, #0x0]
	cmp     r5, r3
	beq     branch_2222de0
	.hword  0x1c92 @ add r2, r2, #0x2
	ldrh    r5, [r2, #0x0]
	.hword  0x1c49 @ add r1, r1, #0x1


p r4, #2
	bne _021DA192
	mov r0, #2
	str r0, [r2]
	add sp, #8
	mov r0, #1
	pop {r3, r4, r5, r6, r7, pc}
_021DA192:
	cmp r4, #1
	bne _021DA1A2
	mov r0, #1
	str r0, [r2]
	mov r2, #2
	str r2, [r1]
	add sp, #8
	pop {r3, r4, r5, r6, r7, pc}
_021DA1A2:
	mov r0, #2
	str r0, [r2]
	mov r0, #3
	str r0, [r1]
	add sp, #8
	mov r0, #1
	pop {r3, r4, r5, r6, r7, pc}
_021DA1B0:
	cmp r5, #2
	bne _021DA1BE
	mov r0, #2
	str r0, [r2]
	add sp, #8
	mov r0, #1
	pop {r3, r4, r5, r6, r7, pc}
_021DA1BE:
	cmp r5, #1
	bne _021DA1CE
	mov r0, #1
	str r0, [r2]
	mov r2, #2
	str r2, [r1]
	add sp, #8
	pop {r3, r4, r5, r6, r7, pc}
_021DA1CE:
	mov r0, #2
	str r0, [r2]
	mov r0, #3
	str r0, [r1]
	add sp, #8
	mov r0, #1
	pop {r3, r4, r5, r6, r7, pc}
_021DA1DC:
	cmp r7, #1
	beq _021DA204
	ldr r0, [sp, #4]
	cmp r0, #1
	beq _021DA204
	cmp r4, r6
	bne _021DA1F2
	add sp, #8
	str r4, [r2]
	mov r0, #1
	pop {r3, r4, r5, r6, r7, pc}
_021DA1F2:
	cmp r4, #1
	bne _021DA1FA
	mov r0, #3
	b _021DA1FC
_021DA1FA:
	mov r0, #1
_021DA1FC:
	str r0, [r2]
	add sp, #8
	mov r0, #1
	pop {r3, r4, r5, r6, r7, pc}
_021DA204:
	cmp r7, #1
	beq _021DA222
	cmp r4, #2
	bne _021DA216
	mov r0, #2
	str r0, [r2]
	add sp, #8
	mov r0, #1
	pop {r3, r4, r5, r6, r7, pc}
_021DA216:
	mov r0, #1
	str r0, [r2]
	mov r2, #3
	str r2, [r1]
	add sp, #8
	pop {r3, r4, r5, r6, r7, pc}
_021DA222:
	cmp r6, #2
	bne _021DA238
	mov r0, #1
	str r0, [r2]
	mov r2, #2
	str r2, [r1]
	ldr r1, [sp, #0x20]
	mov r2, #3
	str r2, [r1]
	add sp, #8
	pop {r3, r4, r5, r6, r7, pc}
_021DA238:
	add sp, #8


f Eternal Blossoms|N|From Lorewalker Cho.|
C Clean off the Bookshelf|QID|31015|NC|M|83.2,29.6|Z|Vale of Eternal Blossoms|N|When standing at the bottom of the stairs, facing Cho, the bookcase is to your left, do this before you turn in the others as it only gives faction at honored or lower|;which is why I put the accept the quest from the item steps after this
T Your Private Collection|QID|31015|M|83.2,29.6|Z|Vale of Eternal Blossoms|N|From Lorewalker Cho.|

F The Defiant (Kun-Lai)|QID|967160002|M|77.55, 95.33|Z|Kun-Lai Summit|ACH|6716;2|N|Between a Saurok and a Hard Place.  This one is inside the Ancient Passage, in a room called 'Deep Rookery'. Its actually easiest to get to from an area in 'The Veiled Stair' called, 'The Secret Aerie'.|
F Role Call |QID|968460004|M|74.48,83.55|CS|Z|Kun-Lai Summit|ACH|6846;4|N|Fish Tales|
F Yaungoil |QID|96847003|M|71.72, 63.02|Z|Kun-Lai Summit|ACH|6847;03|N|The Song of the Yaungol. The 'Weapons Rack' containing the lost 'Sturdy Yaungol Spear' also spawns in this camp.|
F The Emperor's Burden - Part 6 |QID|968550006|M|67.76, 48.33|Z|Kun-Lai Summit|ACH|6855;6|N|The Seven Burdens of Shaohao.|
F Victory in Kun-Lai |QID|968580005|M|63.04, 40.82|Z|Kun-Lai Summit|ACH|6858;5|N|What is Worth Fighting For.|
F Valley of the Emperors|QID|967540001|M|53.06,46.44;50.60, 48.05|CS|Z|Kun-Lai Summit|ACH|6754;1|N|The Dark Heart of the Mogu.  Inside the first room in 'Tomb of the Conqurors. First set of coordubates is tomb entrance. Don't forget the floor is trapped.|
F The Emperor's Burden - Part 7 |QID|968550007|M|40.90, 42.50|Z|Kun-Lai Summit|ACH|6855;7|N|The Seven Burdens of Shaohao.|
F The Emperor's Burden - Part 2 |QID|968550002|M|43.82, 51.19|Z|Kun-Lai Summit|ACH|6855;2|N|The Seven Burdens of Shaohao.|
F Ren Yun the Blind |QID|972300003|M|44.70, 52.37|Z|Kun-Lai Summit|ACH|7230;3|N|Legend of the Brewfathers, there may be a lost recipe {rare spawn} leaned against the shrine.|
F The Hozen Ravage|QID|968500004|M|45.76, 61.90|Z|Kun-Lai Summit|ACH|6850;4|N|Hozen in the Mist.|
F Yaungol Tactics |QID|968470001|M|50.30, 79.30|Z|Kun-Lai Summit|ACH|6847;1|N|The Song of the Yaungol.|

F Together, We Are Strong (Vale)|QID|968580004|M|26.62, 21.49|Z|Vale of Eternal Blossoms|ACH|6858;4|N|What is Worth Fighting For.|

F Trapped in a Strange Land (Townlong)|QID|968470004|M|84.08, 72.86|Z|Townlong Steppes|ACH|6847;4|N|The Song of the Yaungol.|
F Dominance |QID|968470002|M|65.50, 50.10|Z|Townlong Steppes|ACH|6847;2|N|The Song of the Yaungol.|
F The Emperor's Burden - Part 5 |QID|968550005|M|37.74, 62.91|Z|Townlong Steppes|ACH|6855;5|N|The Seven Burdens of Shaohao.|

F Amber (Dread Wastes)|QID|968570003|M|53.56, 16.02;52.52, 10.06|CS


import com.revolgenx.anilib.common.ui.icons.AppIcons

val AppIcons.IcOpenInNew: ImageVector
    get() {
        if (_icOpenInNew != null) {
            return _icOpenInNew!!
        }
        _icOpenInNew = ImageVector.Builder(
            name = "IcOpenInNew", defaultWidth = 24.0.dp, defaultHeight =
            24.0.dp, viewportWidth = 24.0f, viewportHeight = 24.0f
        ).materialPath {
            moveTo(18.0F, 19.0F)
            horizontalLineTo(6.0F)
            curveToRelative(-0.55F, 0.0F, -1.0F, -0.45F, -1.0F, -1.0F)
            verticalLineTo(6.0F)
            curveToRelative(0.0F, -0.55F, 0.45F, -1.0F, 1.0F, -1.0F)
            horizontalLineToRelative(5.0F)
            curveToRelative(0.55F, 0.0F, 1.0F, -0.45F, 1.0F, -1.0F)
            reflectiveCurveToRelative(-0.45F, -1.0F, -1.0F, -1.0F)
            horizontalLineTo(5.0F)
            curveToRelative(-1.11F, 0.0F, -2.0F, 0.9F, -2.0F, 2.0F)
            verticalLineToRelative(14.0F)
            curveToRelative(0.0F, 1.1F, 0.9F, 2.0F, 2.0F, 2.0F)
            horizontalLineToRelative(14.0F)
            curveToRelative(1.1F, 0.0F, 2.0F, -0.9F, 2.0F, -2.0F)
            verticalLineToRelative(-6.0F)
            curveToRelative(0.0F, -0.55F, -0.45F, -1.0F, -1.0F, -1.0F)
            reflectiveCurveToRelative(-1.0F, 0.45F, -1.0F, 1.0F)
            verticalLineToRelative(5.0F)
            curveToRelative(0.0F, 0.55F, -0.45F, 1.0F, -1.0F, 1.0F)

            moveTo(14.0F, 4.0F)
            curveToRelative(0.0F, 0.55F, 0.45F, 1.0F, 1.0F, 1.0F)
            horizontalLineToRelative(2.59F)
            lineToRelative(-9.13F, 9.13F)
            curveToRelative(-0.39F, 0.39F, -0.39F, 1.02F, 0.0F, 1.41F)
            curveToRelative(0.39F, 0.39F, 1.02F, 0.39F, 1.41F, 0.0F)
            lineTo(19.0F, 6.41F)
            verticalLineTo(9.0F)
            curveToRelative(0.0F, 0.55F, 0.45F, 1.0F, 1.0F, 1.0F)
            reflectiveCurveToRelative(1.0F, -0.45F, 1.0F, -1.0F)
            verticalLineTo(4.0F)
            curveToRelative(0.0F, -0.55F, -0.45F, -1.0F, -1.0F, -1.0F)
            horizontalLineToRelative(-5.0F)
            curveToRelative(-0.55F, 0.0F, -1.0F, 0.45F, -1.0F, 1.0F)

            close()
        }.build()
        return _icOpenInNew!!
    }
private var _icOpenInNew: ImageVector? = null

@Preview
@Composable
@Suppress("UnusedPrivateMember")
private fun IconIcOpenInNewPreview() {
    Image(imageVector = AppIcons.IcOpenInNew, contentDescription = null)
}package com.revolgenx.ani


_BOARD_OSPREY440;
			break;
		default:
			/* unknown...leave generic, but get serial # */
			pr_info("%d: osprey eeprom: unknown card type 0x%04x\n",
				btv->c.nr, type);
			break;
		}
		serial = get_unaligned_be32((__be32 *)(ee+6));
	}

	pr_info("%d: osprey eeprom: card=%d '%s' serial=%u\n",
		btv->c.nr, cardid,
		cardid > 0 ? bttv_tvcards[cardid].name : "Unknown", serial);

	if (cardid<0 || btv->c.type == cardid)
		return;

	/* card type isn't set correctly */
	if (card[btv->c.nr] < bttv_num_tvcards) {
		pr_warn("%d: osprey eeprom: Not overriding user specified card type\n",
			btv->c.nr);
	} else {
		pr_info("%d: osprey eeprom: Changing card type from %d to %d\n",
			btv->c.nr, btv->c.type, cardid);
		btv->c.type = cardid;
	}
}

/* ----------------------------------------------------------------------- */
/* AVermedia specific stuff, from  bktr_card.c                             */

static int tuner_0_table[] = {
	TUNER_PHILIPS_NTSC,  TUNER_PHILIPS_PAL /* PAL-BG*/,
	TUNER_PHILIPS_PAL,   TUNER_PHILIPS_PAL /* PAL-I*/,
	TUNER_PHILIPS_PAL,   TUNER_PHILIPS_PAL,
	TUNER_PHILIPS_SECAM, TUNER_PHILIPS_SECAM,
	TUNER_PHILIPS_SECAM, TUNER_PHILIPS_PAL,
	TUNER_PHILIPS_FM1216ME_MK3 };

static int tuner_1_table[] = {
	TUNER_TEMIC_NTSC,  TUNER_TEMIC_PAL,
	TUNER_TEMIC_PAL,   TUNER_TEMIC_PAL,
	TUNER_TEMIC_PAL,   TUNER_TEMIC_PAL,
	TUNER_TEMIC_4012FY5, TUNER_TEMIC_4012FY5, /* TUNER_TEMIC_SECAM */
	TUNER_TEMIC_4012FY5, TUNER_TEMIC_PAL};

static void avermedia_eeprom(struct bttv *btv)
{
	int tuner_make, tuner_tv_fm, tuner_format, tuner_type = 0;

	tuner_make      = (eeprom_data[0x41] & 0x7);
	tuner_tv_fm     = (eeprom_data[0x41] & 0x18) >> 3;
	tuner_format    = (eeprom_data[0x42] & 0xf0) >> 4;
	btv->has_remote = (eeprom_data[0x42] & 0x01);

	if (tuner_make == 0 || tuner_make == 2)
		if (tuner_format <= 0x0a)
			tuner_type = tuner_0_table[tuner_format];
	if (tuner_make == 1)
		if (tuner_format <= 9)
			tuner_type = tuner_1_table[tuner_format];

	if (tuner_make == 4)
		if (tuner_format == 0x09)
			tuner_type = TUNER_LG_NTSC_NEW_TAPC; /* TAPC-G702P */

	pr_info("%d: Avermedia eeprom[0x%02x%02x]: tuner=",
		btv->c.nr, eeprom_data[0x41], eeprom_data[0x42]);
	if (tuner_type) {
		btv->tuner_type = tuner_type;
		pr_cont("%d", tuner_type);
	} else
		pr_cont("Unknown type");
	pr_cont(" radio:%s remote control:%s\n",
	       tuner_tv_fm     ? "yes" : "no",
	       btv->has_remote ? "yes" : "no");
}

/*
 * For Voodoo TV/FM and Voodoo 200.  These cards' tuners use a TDA9880
 * analog demod, which is not I2C controlled like the newer and more common
 * TDA9887 series.  Instead it has two tri-state input pins, S0 and S1,
 * that control the IF for the video and audio.  Apparently, bttv GPIO
 * 0x10000 is connected to S0.  S0 low selects a 38.9 MHz VIF for B/G/D/K/I
 * (i.e., PAL) while high selects 45.75 MHz for M/N (i.e., NTSC).
 */
u32 bttv_tda9880_setnorm(struct bttv *btv, u32 gpiobits)
{

	if (btv->audio_input == TVAUDIO_INPUT_TUNER) {
		if (bttv_tvnorms[btv->tvnorm].v4l2_id & V4L2_STD_MN)
			gpiobits |= 0x10000;
		else
			gpiobits &= ~0x10000;
	}

	gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpiobits);
	return gpiobits;
}

/*
 * reset/enable the MSP on some Hauppauge cards
 * Thanks to Kyösti Mälkki (kmalkki@cc.hut.fi)!
 *
 * Hauppauge:  pin  5
 * Voodoo:     pin 20
 */
static void boot_msp34xx(struct bttv *btv, int pin)
{
	int mask = (1 << pin);

	gpio_inout(mask,mask);
	gpio_bits(mask,0);
	mdelay(2);
	udelay(500);
	gpio_bits(mask,mask);

	if (bttv_gpio)
		bttv_gpio_tracking(btv,"msp34xx");
	if (bttv_verbose)
		pr_info("%d: Hauppauge/Voodoo msp34xx: reset line init [%d]\n",
			btv->c.nr, pin);
}

/* ----------------------------------------------------------------------- */
/*  Imagenation L-Model PXC200 Framegrabber */
/*  This is basically the same procedure as
 *  used by Alessandro Rubini in his pxc200
 *  driver, but using BTTV functions */

static void init_PXC200(struct bttv *btv)
{
	static int vals[] = { 0x08, 0x09, 0x0a, 0x0b, 0x0d, 0x0d, 0x01, 0x02,
			      0x03, 0x04, 0x05, 0x06, 0x00 };
	unsigned int i;
	int tmp;
	u32 val;

	/* Initialise GPIO-connected stuff */
	gpio_inout(0xffffff, (1<<13));
	gpio_write(0);
	udelay(3);
	gpio_write(1<<13);
	/* GPIO inputs are pulled up, so no need to drive
	 * reset pin any longer */
	gpio_bits(0xffffff, 0);
	if (bttv_gpio)
		bttv_gpio_tracking(btv,"pxc200");

	/*  we could/should try and reset/control the AD pots? but
	    right now  we simply  turned off the crushing.  Without
	    this the AGC


e i'r Chwith (RTL)","menu":"Golygu Dolen","name":"Enw","noAnchors":"(Dim angorau ar gael yn y ddogfen)","noEmail":"Teipiwch gyfeiriad yr e-bost","noUrl":"Teipiwch URL y ddolen","other":"<eraill>","popupDependent":"Dibynnol (Netscape)","popupFeatures":"Nodweddion Ffenestr Bop","popupFullScreen":"Sgrin Llawn (IE)","popupLeft":"Safle Chwith","popupLocationBar":"Bar Safle","popupMenuBar":"Dewislen","popupResizable":"Ailfeintiol","popupScrollBars":"Barrau Sgrolio","popupStatusBar":"Bar Statws","popupToolbar":"Bar Offer","popupTop":"Safle Top","rel":"Perthynas","selectAnchor":"Dewiswch Angor","styles":"Arddull","tabIndex":"Indecs Tab","target":"Targed","targetFrame":"<ffrâm>","targetFrameName":"Enw Ffrâm y Targed","targetPopup":"<ffenestr bop>","targetPopupName":"Enw Ffenestr Bop","title":"Dolen","toAnchor":"Dolen at angor yn y testun","toEmail":"E-bost","toUrl":"URL","toolbar":"Dolen","type":"Math y Ddolen","unlink":"Datgysylltu","upload":"Lanlwytho"},"list":{"bulletedlist":"Mewnosod/Tynnu Rhestr Bwled","numberedlist":"Mewnosod/Tynnu Rhestr Rhifol"},"liststyle":{"armenian":"Rhifau Armeneg","bulletedTitle":"Priodweddau Rhestr Fwled","circle":"Cylch","decimal":"Degol (1, 2, 3, ayyb.)","decimalLeadingZero":"Degol â sero arweiniol (01, 02, 03, ayyb.)","disc":"Disg","georgian":"Rhifau Sioraidd (an, ban, gan, ayyb.)","lowerAlpha":"Alffa Is (a, b, c, d, e, ayyb.)","lowerGreek":"Groeg Is (alpha, beta, gamma, ayyb.)","lowerRoman":"Rhufeinig Is (i, ii, iii, iv, v, ayyb.)","none":"Dim","notset":"<heb osod>","numberedTitle":"Priodweddau Rhestr Rifol","square":"Sgwâr","start":"Dechrau","type":"Math","upperAlpha":"Alffa Uwch (A, B, C, D, E, ayyb.)","upperRoman":"Rhufeinig Uwch (I, II, III, IV, V, ayyb.)","validateStartNumber":"Rhaid bod y rhif cychwynnol yn gyfanrif."},"magicline":{"title":"Mewnosod paragraff yma"},"maximize":{"maximize":"Mwyhau","minimize":"Lleihau"},"newpage":{"toolbar":"Tudalen newydd"},"pagebreak":{"alt":"Toriad Tudalen","toolbar":"Mewnosod Toriad Tudalen i Argraffu"},"pastetext":{"button":"Gludo fel testun plaen","title":"Gludo fel Testun Plaen"},"pastefromword":{"confirmCleanup":"Mae'r testun rydych chi am ludo wedi'i gopïo o Word. Ydych chi am ei lanhau cyn ei ludo?","error":"Doedd dim modd glanhau y data a ludwyd oherwydd gwall mewnol","title":"Gludo o Word","toolbar":"Gludo o Word"},"preview":{"preview":"Rhagolwg"},"print":{"toolbar":"Argraffu"},"removeformat":{"toolbar":"Tynnu Fformat"},"save":{"toolbar":"Cadw"},"selectall":{"toolbar":"Dewis Popeth"},"showblocks":{"toolbar":"Dangos Blociau"},"sourcearea":{"toolbar":"HTML"},"specialchar":{"options":"Opsiynau Nodau Arbennig","title":"Dewis Nod Arbennig","toolbar":"Mewnosod Nod