	"blue",
	"green",
}

// UnmarshalJSON implements json.Unmarshaler.
func (j *EnumMyStringTypedEnum) UnmarshalJSON(b []byte) error {
	var v string
	if err := json.Unmarshal(b, &v); err != nil {
		return err
	}
	var ok bool
	for _, expected := range enumValues_EnumMyStringTypedEnum {
		if reflect.DeepEqual(v, expected) {
			ok = true
			break
		}
	}
	if !ok {
		return fmt.Errorf("invalid value (expected one of %#v): %#v", enumValues_EnumMyStringTypedEnum, v)
	}
	*j = EnumMyStringTypedEnum(v)
	return nil
}

// MarshalJSON implements json.Marshaler.
func (j *EnumMyNullTypedEnum) MarshalJSON() ([]byte, error) {
	return json.Marshal(j.Value)
}

// UnmarshalJSON implements json.Unmarshaler.
func (j *EnumMyMixedUntypedEnum) UnmarshalJSON(b []byte) error {
	var v struct {
		Value interface{}
	}
	if err := json.Unmarshal(b, &v.Value); err != nil {
		return err
	}
	var ok bool
	for _, expected := range enumValues_EnumMyMixedUntypedEnum {
		if reflect.DeepEqual(v.Value, expected) {
			ok = true
			break
		}
	}
	if !ok {
		return fmt.Errorf("invalid value (expected one of %#v): %#v", enumValues_EnumMyMixedUntypedEnum, v.Value)
	}
	*j = EnumMyMixedUntypedEnum(v)
	return nil
}

// MarshalJSON implements json.Marshaler.
func (j *EnumMyMixedUntypedEnum) MarshalJSON() ([]byte, error) {
	return json.Marshal(j.Value)
}

// UnmarshalJSON implements json.Unmarshaler.
func (j *EnumMyMixedTypeEnum) UnmarshalJSON(b []byte) error {
	var v struct {
		Value interface{}
	}
	if err := json.Unmarshal(b, &v.Value); err != nil {
		return err
	}
	var ok bool
	for _, expected := range enumValues_EnumMyMixedTypeEnum {
		if reflect.DeepEqual(v.Value, expected) {
			ok = true
			break
		}
	}
	if !ok {
		return fmt.Errorf("invalid value (expected one of %#v): %#v", enumValues_EnumMyMixedTypeEnum, v.Value)
	}
	*j = EnumMyMixedTypeEnum(v)
	return nil
}

var enumValues_EnumMyStringUntypedEnum = []interface{}{
	"red",
	"blue",
	"green",
}

// UnmarshalJSON implements json.Unmarshaler.
func (j *EnumMyStringUntypedEnum) UnmarshalJSON(b []byte) error {
	var v string
	if err := json.Unmarshal(b, &v); err != nil {
		return err
	}
	var ok bool
	for _, expected := range enumValues_EnumMyStringUntypedEnum {
		if reflect.DeepEqual(v, expected) {
			ok = true
			break
		}
	}
	if !ok {
		return fmt.Errorf("invalid value (expected one of %#v): %#v", enumValues_EnumMyStringUntypedEnum, v)
	}
	*j = EnumMyStringUntypedEnum(v)
	return nil
}

// MarshalJSON implements json.Marshaler.
func (j *EnumMyMixedTypeEnum) MarshalJSON() ([]byte, error) {
	return json.Marshal(j.Value)
}

// UnmarshalJSON implements json.Unmarshaler.
func (j *EnumMyIntegerTypedEnum) UnmarshalJSON(b []byte) error {
	var v int
	if err := json.Unmarshal(b, &v); er


UInt32())
        assertEquals(3.toULong(), reader.readUInt64())
    }

    @Test
    fun `ParseDnsPrinter`() {
        val data = ubyteArrayOf(
            0x00u, 0x00u,
            0x84u, 0x00u, 0x00u, 0x00u, 0x00u, 0x01u, 0x00u, 0x00u, 0x00u, 0x06u, 0x04u, 0x5fu, 0x69u, 0x70u, 0x70u, 0x04u,
            0x5fu, 0x74u, 0x63u, 0x70u, 0x05u, 0x6cu, 0x6fu, 0x63u, 0x61u, 0x6cu, 0x00u, 0x00u, 0x0cu, 0x00u, 0x01u, 0x00u,
            0x00u, 0x11u, 0x94u, 0x00u, 0x1eu, 0x1bu, 0x42u, 0x72u, 0x6fu, 0x74u, 0x68u, 0x65u, 0x72u, 0x20u, 0x44u, 0x43u,
            0x50u, 0x2du, 0x4cu, 0x33u, 0x35u, 0x35u, 0x30u, 0x43u, 0x44u, 0x57u, 0x20u, 0x73u, 0x65u, 0x72u, 0x69u, 0x65u,
            0x73u, 0xc0u, 0x0cu, 0xc0u, 0x27u, 0x00u, 0x10u, 0x80u, 0x01u, 0x00u, 0x00u, 0x11u, 0x94u, 0x02u, 0x53u, 0x09u,
            0x74u, 0x78u, 0x74u, 0x76u, 0x65u, 0x72u, 0x73u, 0x3du, 0x31u, 0x08u, 0x71u, 0x74u, 0x6fu, 0x74u, 0x61u, 0x6cu,
            0x3du, 0x31u, 0x42u, 0x70u, 0x64u, 0x6cu, 0x3du, 0x61u, 0x70u, 0x70u, 0x6cu, 0x69u, 0x63u, 0x61u, 0x74u, 0x69u,
            0x6fu, 0x6eu, 0x2fu, 0x6fu, 0x63u, 0x74u, 0x65u, 0x74u, 0x2du, 0x73u, 0x74u, 0x72u, 0x65u, 0x61u, 0x6du, 0x2cu,
            0x69u, 0x6du, 0x61u, 0x67u, 0x65u, 0x2fu, 0x75u, 0x72u, 0x66u, 0x2cu, 0x69u, 0x6du, 0x61u, 0x67u, 0x65u, 0x2fu,
            0x6au, 0x70u, 0x65u, 0x67u, 0x2cu, 0x69u, 0x6du, 0x61u, 0x67u, 0x65u, 0x2fu, 0x70u, 0x77u, 0x67u, 0x2du, 0x72u,
            0x61u, 0x73u, 0x74u, 0x65u, 0x72u, 0x0cu, 0x72u, 0x70u, 0x3du, 0x69u, 0x70u, 0x70u, 0x2fu, 0x70u, 0x72u, 0x69u,
            0x6eu, 0x74u, 0x05u, 0x6eu, 0x6fu, 0x74u, 0x65u, 0x3du, 0x1eu, 0x74u, 0x79u, 0x3du, 0x42u, 0x72u, 0x6fu, 0x74u,
            0x68u, 0x65u, 0x72u, 0x20u, 0x44u, 0x43u, 0x50u, 0x2du, 0x4cu, 0x33u, 0x35u, 0x35u, 0x30u, 0x43u, 0x44u, 0x57u,
            0x20u, 0x73u, 0x65u, 0x72u, 0x69u, 0x65u, 0x73u, 0x25u, 0x70u, 0x72u, 0x6fu, 0x64u, 0x75u, 0x63u, 0x74u, 0x3du,
            0x28u, 0x42u, 0x72u, 0x6fu, 0x74u, 0x68u, 0x65u, 0x72u, 0x20u, 0x44u, 0x43u, 0x50u, 0x2du, 0x4cu, 0x33u, 0x35u,
            0x35u, 0x30u, 0


Type {@link module:qm.Record}.
    *
2. `rec2` - The second record. Type {@link module:qm.Record}.
    *
 Returns a `boolean` value.
    * @returns {Array.<module:qm.RecordSet>} An array containing the smaller record sets. The records are split according the callback function.
    * @example
    * // import qm module
    * var qm = require("qminer");
    * // create a new base containing one store
    * var base = new qm.Base({
    *    mode: "createClean",
    *    schema: [{
    *        name: "SocialGames",
    *        fields: [
    *            { name: "Title", type: "string" },
    *            { name: "Type", type: "string" },
    *            { name: "MinPlayers", type: "int" },
    *            { name: "MaxPlayers", type: "int" }
    *        ]
    *    }]
    * });
    * // set new records in the store
    * base.store("SocialGames").push({ Title: "DungeonsAndDragons", Type: "Role-Playing", MinPlayers: 5, MaxPlayers: 5 });
    * base.store("SocialGames").push({ Title: "Dobble", Type: "Card", MinPlayers: 2, MaxPlayers: 8 });
    * base.store("SocialGames").push({ Title: "Settlers of Catan", Type: "Board", MinPlayers: 3, MaxPlayers: 4 });
    * base.store("SocialGames").push({ Title: "Munchkin", Type: "Card", MinPlayers: 3, MaxPlayers: 6 });
    * // create a record set out of the records of the store
    * var recordSet = base.store("SocialGames").allRecords;
    * // sort the records by MinPlayers in ascending order
    * recordSet.sortByField("MinPlayers", true);
    * // split the record set by the minimum number of players
    * // returns an array containing three record sets: the first containing the "DungeonsAndDragons" record,
    * // the second containing the "Settlers of Catan" and "Munchkin" records and the third containing the
    * // "Dobble" record
    * var arr = recordSet.split(function (rec, rec2) { return rec.MinPlayers < rec2.MinPlayers; });
    * base.close();
    */
 exports.RecordSet.prototype.split = function (callback) {return [Object.create(require('qminer').RecordSet.prototype)]; };
/**
    * Deletes the records, that are also in the second record set.
    * @param {module:qm.RecordSet} rs - The second record set.
    * @returns {module:qm.RecordSet} Self. Contains only the records, that are not in `rs`.
    * @example
    * // import qm module
    * var qm = require('qminer');
    * // create a new base containing one store
    * var base = new qm.Base({
    *    mode: "createClean",
    *    schema: [{
    *        name: "BookWriters",
    *        fields: [
    *            { name: "Name", type: "string" },
    *            { name: "Genre", type: "string" },
    *            { name: "Books", type: "string_v" }
    *        ]
    *    }]
    * });
    * // set new records in the store
    * base.store("BookWriters").push({ Name: "Terry Pratchett", Genre: "Fantasy", Books: ["The Colour of Magic", "Going Postal", "Mort", "Guards! Guards!"] });
    * base.store("BookWriters").push({ Name: "Douglas Adams", Genre: "Sci-fi", Books: ["The Hitchhiker's Guide to the Galaxy", "So Long, and Thanks for All the Fish"] });
    * base.store("BookWriters").push({ Name: "Fyodor Dostoyevsky", Genre: "Drama", Books: ["Crime and Punishment", "Demons"] });
    * base.


Triangles( 0,  1,  2, 0x0,  0,  3,  4, 0x0),
    gsSP2Triangles( 0,  5,  1, 0x0,  0,  2,  6, 0x0),
    gsSP2Triangles( 0,  6,  7, 0x0,  0,  7,  3, 0x0),
    gsSP2Triangles( 8,  9, 10, 0x0,  8, 11,  9, 0x0),
    gsSP2Triangles( 8, 12, 13, 0x0,  8, 13, 14, 0x0),
    gsSP2Triangles( 8, 15, 11, 0x0,  8, 14, 15, 0x0),
    gsSPEndDisplayList(),
].flat();

// 0x0700BA28 - 0x0700BB18
export const wf_seg7_dl_0700BA28 = [
    gsDPPipeSync(),
    gsDPSetCombineMode(G_CC_MODULATERGB, G_CC_MODULATERGB),
    gsSPClearGeometryMode(G_SHADING_SMOOTH),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD),
    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
    gsDPTileSync(),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, 5, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRROR, 5, G_TX_NOLOD),
    gsDPSetTileSize(0, 0, 0, (32 - 1) << G_TEXTURE_IMAGE_FRAC, (32 - 1) << G_TEXTURE_IMAGE_FRAC),
    gsSPDisplayList(wf_seg7_dl_0700B750),
    gsDPTileSync(),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_CLAMP, 5, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRROR, 5, G_TX_NOLOD),
    gsDPSetTileSize(0, 0, 0, (32 - 1) << G_TEXTURE_IMAGE_FRAC, (32 - 1) << G_TEXTURE_IMAGE_FRAC),
    gsSPDisplayList(wf_seg7_dl_0700B790),
    gsDPTileSync(),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, 5, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRROR, 5, G_TX_NOLOD),
    gsDPSetTileSize(0, 0, 0, (32 - 1) << G_TEXTURE_IMAGE_FRAC, (32 - 1) << G_TEXTURE_IMAGE_FRAC),
    gsSPDisplayList(wf_seg7_dl_0700B808),
    gsDPTileSync(),
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_CLAMP, 5, G_TX_NOLOD, G_TX_WRAP | G_TX_NOMIRR


     logit_teacher,
            x9_teacher,
            x8_teacher,
            x7_teacher,
            x6_teacher,
            x5_teacher,
            x4_teacher,
        ) = self.teacher(bev_seq_teacher)
        kl_loss_mean = nn.KLDivLoss(size_average=True, reduce=True)

        target_x5 = x5_teacher.permute(0, 2, 3, 1).reshape(
            num_agent * batch_size * 16 * 16, -1
        )
        student_x5 = x5.permute(0, 2, 3, 1).reshape(
            num_agent * batch_size * 16 * 16, -1
        )
        kd_loss_x5 = kl_loss_mean(
            F.log_softmax(student_x5, dim=1), F.softmax(target_x5, dim=1)
        )

        target_x6 = x6_teacher.permute(0, 2, 3, 1).reshape(
            num_agent * batch_size * 32 * 32, -1
        )
        student_x6 = x6.permute(0, 2, 3, 1).reshape(
            num_agent * batch_size * 32 * 32, -1
        )
        kd_loss_x6 = kl_loss_mean(
            F.log_softmax(student_x6, dim=1), F.softmax(target_x6, dim=1)
        )

        target_x7 = x7_teacher.permute(0, 2, 3, 1).reshape(
            num_agent * batch_size * 64 * 64, -1
        )
        student_x7 = x7.permute(0, 2, 3, 1).reshape(
            num_agent * batch_size * 64 * 64, -1
        )
        kd_loss_x7 = kl_loss_mean(
            F.log_softmax(student_x7, dim=1), F.softmax(target_x7, dim=1)
        )

        target_x4 = x4_teacher.permute(0, 2, 3, 1).reshape(
            num_agent * batch_size * 32 * 32, -1
        )
        student_x4 = fused_layer.permute(0, 2, 3, 1).reshape(
            num_agent * batch_size * 32 * 32, -1
        )
        kd_loss_fused_layer = kl_loss_mean(
            F.log_softmax(student_x4, dim=1), F.softmax(target_x4, dim=1)
        )

        return kd_weight * (kd_loss_x5 + kd_loss_x6 + kd_loss_x7 + kd_loss_fused_layer)


    content: "\2663\00A0\2663\00A0\2663 \A\2663\00A0\00A0\2663 \A\2663\00A0\2663\00A0\2663";
}
.playingCards .card.rank-9.clubs .suit:after {
    content: "\2663\00A0\2663\00A0\2663 \A\2663\00A0\2663\00A0\2663 \A\2663\00A0\2663\00A0\2663";
}
.playingCards .card.rank-10.clubs .suit:after {
    content: "\2663\00A0\2663\00A0\2663 \A\2663\00A0\2663\00A0\2663\00A0\2663 \A\2663\00A0\2663\00A0\2663";
}

/*____________ symbols in the middle (faces as images) ____________*/

.playingCards.faceImages .card.rank-j .suit:after,
.playingCards.faceImages .card.rank-q .suit:after,
.playingCards.faceImages .card.rank-k .suit:after {
    content: '';
}
.playingCards.faceImages .card.rank-j,
.playingCards.faceImages .card.rank-q,
.playingCards.faceImages .card.rank-k,
.playingCards.faceImages .card.joker {
    background-repeat: no-repeat;
    background-position: -1em 0;
    /* @change: smaller cards: more negative distance from the left
       bigger cards: 0 or more positive distance from the left */

    /* for a centered full background image:
    background-position: .35em 0;
    -moz-background-size: contain;
    -o-background-size: contain;
    -webkit-background-size: contain;
    -khtml-background-size: contain;
    background-size: contain;
    */
}
/*
.playingCards.faceImages .card.rank-j.diams  { background-image: url(faces/JD.gif); }
.playingCards.faceImages .card.rank-j.hearts { background-image: url(faces/JH.gif); }
.playingCards.faceImages .card.rank-j.spades { background-image: url(faces/JS.gif); }
.playingCards.faceImages .card.rank-j.clubs  { background-image: url(faces/JC.gif); }

.playingCards.faceImages .card.rank-q.diams  { background-image: url(faces/QD.gif); }
.playingCards.faceImages .card.rank-q.hearts { background-image: url(faces/QH.gif); }
.playingCards.faceImages .card.rank-q.spades { background-image: url(faces/QS.gif); }
.playingCards.faceImages .card.rank-q.clubs  { background-image: url(faces/QC.gif); }

.playingCards.faceImages .card.rank-k.diams  { background-image: url(faces/KD.gif); }
.playingCards.faceImages .card.rank-k.hearts { background-image: url(faces/KH.gif); }
.playingCards.faceImages .card.rank-k.spades {


 Test with custom config
python3 config_resolver.py --config ./my-config.yaml --info

# Test with environment variable
RADIO_GAGA_CONFIG=./test.yaml python3 config_resolver.py --info
```
# 股票分析系统

这是一个自动化股票分析系统，可以每日监控多只股票的表现，分析买入机会，并自动发送包含分析结果的邮件报告。

## 主要功能

- 获取股票数据：价格、交易量、技术指标等
- 计算关键技术指标：移动平均线、RSI、MACD、布林带等
- 检测异常价格变动（如股票拆分）
- 基于多种买入信号进行分析：
  - RSI低于阈值（超卖）
  - 价格低于50日均线但高于200日均线（技术回调）
  - 价格在52周范围的下1/3位置
  - 黄金交叉形态（50日均线在200日均线之上）且价格在50日均线附近
- 生成股价走势图
- 发送包含完整分析的HTML格式邮件报告
- 通过GitHub Actions自动化运行

## 项目结构

```
stock_analysis/
├── stock_analysis/           # 主模块
│   ├── __init__.py           # 包初始化
│   ├── data.py               # 数据获取和处理
│   ├── indicators.py         # 技术指标计算
│   ├── strategies.py         # 买入策略
│   ├── visualization.py      # 图表生成
│   ├── reporting.py          # 邮件报告
│   └── utils.py              # 工具函数
├── scripts/
│   └── run_analysis.py       # 主运行脚本
├── config.yaml               # 配置文件
└── .github/
    └── workflows/
        └── stock-analysis.yml  # GitHub Actions工作流
```

## 配置说明

系统通过`config.yaml`文件进行配置：

```yaml
# Alpha Vantage API配置
api_key: ""  # 留空使用环境变量 ALPHA_VANTAGE_API_KEY

# 股票配置
symbols:
  - AAPL
  - NVDA
  - MSFT
  - TSLA

# 股票中文名称映射
symbol_names:
  TSLA: "特斯拉"
  AAPL: "苹果"
  MSFT: "微软"
  NVDA: "英伟达"

# 策略参数
strategy:
  rsi_threshold: 30              # RSI超卖阈值
  price_position_threshold: 33   # 价格位置阈值(%)
  ma_proximity_threshold: 0.05   # 均线附近阈值(5%)
  anomaly_threshold: 0.15        # 异常价格变动阈值(15%)
```

## 使用方法

### 命令行参数

- `--config`：指定配置文件路径（默认为`config.yaml`）
- `--symbol`：分析单一股票（例如：`--symbol TSLA`）
- `--symbols`：分析多只股票（例如：`--symbols TSLA,AAPL,NVDA`）
- `--no-email`：仅进行分析，不发送邮件
- `--cache-expiry`：设置缓存过期时间（小时）

### GitHub Actions自动化

该项目配置了GitHub Actions工作流，可以：
- 每个工作日美国东部时间16:30自动运行
- 通过手动触发工作流并指定股票代码运行

## 环境要求

- Python 3.6+
- 依赖库：requests, pandas, numpy, matplotlib, pyyaml

## 注意事项

- Alpha Vantage API有使用频率限制，建议不要过于频繁地运行脚本
- 邮件发送需要正确配置邮箱服务器信息
- Gmail用户需要使用应用密码而不是账户密码
# Developer Documentation – JAM-Tree

Esta documentação é voltada para contribuidores e desenvolvedores que desejam entender a arquitetura, executar testes e colaborar com o projeto JAM-Tree.

## 1. Visão Geral da Arquitetura

O


_liab_weight,
            init_liab_weight,
            liquidation_fee,
            maker_fee,
            taker_fee,
            base_lot_size,
            quote_lot_size,
        };

        // Initialize the Bids
        let _bids = BookSide::load_and_init(bids_ai, program_id, DataType::Bids, &rent)?;

        // Initialize the Asks
        let _asks = BookSide::load_and_init(asks_ai, program_id, DataType::Asks, &rent)?;

        // Initialize the EventQueue
        // TODO: check that the event queue is reasonably large
        let _event_queue = EventQueue::load_and_init(event_queue_ai, program_id, &rent)?;

        // Now initialize the PerpMarket itself
        let _perp_market = PerpMarket::load_and_init(
            perp_market_ai,
            program_id,
            mango_group_ai,
            bids_ai,
            asks_ai,
            event_queue_ai,
            mngo_vault_ai,
            &mango_group,
            &rent,
            base_lot_size,
            quote_lot_size,
            rate,
            max_depth_bps,
            target_period_length,
            mngo_per_period,
            exp,
        )?;

        Ok(())
    }

    #[inline(never)]
    /// Deposit instruction
    fn deposit(program_id: &Pubkey, accounts: &[AccountInfo], quantity: u64) -> MangoResult<()> {
        // TODO - consider putting update crank here
        const NUM_FIXED: usize = 9;
        let accounts = array_ref![accounts, 0, NUM_FIXED];
        let [
            mango_group_ai,         // read
            mango_account_ai,       // write
            owner_ai,               // read
            mango_cache_ai,         // read
            root_bank_ai,           // read
            node_bank_ai,           // write
            vault_ai,               // write
            token_prog_ai,          // read
            owner_token_account_ai, // write
        ] = accounts;
        check_eq!(token_prog_ai.key, &spl_token::ID, MangoErrorCode::InvalidProgramId)?;

        let mango_group = MangoGroup::load_checked(mango_group_ai, program_id)?;
        let mut mango_account =
            MangoAccount::load_mut_checked(mango_account_ai, program_id, mango_group_ai.key)?;

        check!(!mango_account.is_bankrupt, MangoErrorCode::Bankrupt)?;

        let mango_cache = MangoCache::load_checked(mango_cache_ai, program_id, &mango_group)?;

        let token_index = mango_group
            .find_root_bank_index(root_bank_ai.key)
            .ok_or(throw_err!(MangoErrorCode::InvalidRootBank))?;

        // Find the node_bank pubkey in root_bank, if not found error
        let root_bank = RootBank::load_checked(root_bank_ai, program_id)?;
        check!(root_bank.node_banks.contains(node_bank_ai.key), MangoErrorCode::InvalidNodeBank)?;
        let mut node_bank = NodeBank::load_mut_checked(node_bank_ai, program_id)?;
        check_eq!(&node_bank.vault, vault_ai.key, MangoErrorCode::InvalidVault)?;

        // deposit into node bank token vault using invoke_transfer
        invoke_transfer(token_prog_ai, owner_token_account_ai, vault_ai, owner_ai, &[], quantity)?;

        // Check validity of root bank cache
        let now_ts = Clock::get()?.unix_timestamp as u64;


ied_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);

#endif

} // namespace detail

} // namespace boost

#define BOOST_EXPLICIT_OPERATOR_BOOL()\
    BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const\
    {\
        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
    }

#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
    BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\
    {\
        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
    }

#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
    BOOST_FORCEINLINE BOOST_CONSTEXPR operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\
    {\
        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
    }

#else // !defined(BOOST_NO_UNSPECIFIED_BOOL)

#define BOOST_EXPLICIT_OPERATOR_BOOL()\
    BOOST_FORCEINLINE operator bool () const\
    {\
        return !this->operator! ();\
    }

#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
    BOOST_FORCEINLINE operator bool () const BOOST_NOEXCEPT\
    {\
        return !this->operator! ();\
    }

#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
    BOOST_FORCEINLINE BOOST_CONSTEXPR operator bool () const BOOST_NOEXCEPT\
    {\
        return !this->operator! ();\
    }

#endif // !defined(BOOST_NO_UNSPECIFIED_BOOL)

#endif // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)

#endif // BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
#ifndef BOOST_CORE_CHECKED_DELETE_HPP
#define BOOST_CORE_CHECKED_DELETE_HPP

// MS compatible compilers support #pragma once

#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif

//
//  boost/checked_delete.hpp
//
//  Copyright (c) 2002, 2003 Peter Dimov
//  Copyright (c) 2003 Daniel Frey
//  Copyright (c) 2003 Howard Hinnant
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  See http://www.boost.org/libs/core/doc/html/core/checked_delete.html for documentation.
//

namespace boost
{

// verify that types are complete for increased safety

template<class T> inline void checked_delete(T * x)
{
    // intentionally complex - simplification causes regressions
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
}

template<class T> inline void checked_array_delete(T * x)
{
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete [] x;
}

template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {
        // boost:: disables ADL
        boost::checked_delete(x);
    }
};

template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {
        boost::checked_array_delete(x);
    }
};

} // namespace boost

#endif  // #ifndef BOOST_CORE_CHECKED_DELETE_


6M", Value: 909200718},
	{Name: "V4L2_PIX_FMT_NV21", Value: 825382478},
	{Name: "V4L2_PIX_FMT_NV21M", Value: 825380174},
	{Name: "V4L2_PIX_FMT_NV24", Value: 875714126},
	{Name: "V4L2_PIX_FMT_NV42", Value: 842290766},
	{Name: "V4L2_PIX_FMT_NV61", Value: 825644622},
	{Name: "V4L2_PIX_FMT_NV61M", Value: 825642318},
	{Name: "V4L2_PIX_FMT_OV511", Value: 825308495},
	{Name: "V4L2_PIX_FMT_OV518", Value: 942749007},
	{Name: "V4L2_PIX_FMT_PAC207", Value: 925905488},
	{Name: "V4L2_PIX_FMT_PAL8", Value: 944521552},
	{Name: "V4L2_PIX_FMT_PJPG", Value: 1196444240},
	{Name: "V4L2_PIX_FMT_PWC1", Value: 826496848},
	{Name: "V4L2_PIX_FMT_PWC2", Value: 843274064},
	{Name: "V4L2_PIX_FMT_RGB24", Value: 859981650},
	{Name: "V4L2_PIX_FMT_RGB32", Value: 876758866},
	{Name: "V4L2_PIX_FMT_RGB332", Value: 826427218},
	{Name: "V4L2_PIX_FMT_RGB444", Value: 875836498},
	{Name: "V4L2_PIX_FMT_RGB555", Value: 1329743698},
	{Name: "V4L2_PIX_FMT_RGB555X", Value: 1363298130},
	{Name: "V4L2_PIX_FMT_RGB565", Value: 1346520914},
	{Name: "V4L2_PIX_FMT_RGB565X", Value: 1380075346},
	{Name: "V4L2_PIX_FMT_S5C_UYVY_JPG", Value: 1229141331},
	{Name: "V4L2_PIX_FMT_SBGGR10", Value: 808535874},
	{Name: "V4L2_PIX_FMT_SBGGR10ALAW8", Value: 943800929},
	{Name: "V4L2_PIX_FMT_SBGGR10DPCM8", Value: 943800930},
	{Name: "V4L2_PIX_FMT_SBGGR10P", Value: 1094795888},
	{Name: "V4L2_PIX_FMT_SBGGR12", Value: 842090306},
	{Name: "V4L2_PIX_FMT_SBGGR16", Value: 844257602},
	{Name: "V4L2_PIX_FMT_SBGGR8", Value: 825770306},
	{Name: "V4L2_PIX_FMT_SE401", Value: 825242707},
	{Name: "V4L2_PIX_FMT_SGBRG10", Value: 808534599},
	{Name: "V4L2_PIX_FMT_SGBRG10ALAW8", Value: 943802209},
	{Name: "V4L2_PIX_FMT_SGBRG10DPCM8", Value: 943802210},
	{Name: "V4L2_PIX_FMT_SGBRG10P", Value: 1094797168},
	{Name: "V4L2


using System;
using System.Diagnostics;
using System.Windows;
using System.Windows.Input;
using FirstFloor.ModernUI.Commands;
using FirstFloor.ModernUI.Helpers;
using FirstFloor.ModernUI.Windows.Controls;
using FirstFloor.ModernUI.Windows.Media;

namespace FirstFloor.ModernUI.Windows.Navigation {
    public static class LinkCommands {
        public static RoutedUICommand NavigateLink { get; } = new RoutedUICommand(UiStrings.NavigateLink, "NavigateLink", typeof(LinkCommands));

        // Dunno what I’m doing here, to be honest… RoutedUICommand? What the hell is that?
        public static DelegateCommand<object> NavigateLinkMainWindow { get; } = new DelegateCommand<object>(uri => {
            if (uri != null) {
                var s = uri.ToString();
                if (s.StartsWith("http://") || s.StartsWith("https://")) {
                    try {
                        Process.Start(s);
                    } catch (Exception) {
                        NonfatalError.Notify("Can’t open link", $"App tried to open: “{s}”");
                    }
                    return;
                }

                var mainWindow = Application.Current?.MainWindow;
                var u = new Uri(s, UriKind.RelativeOrAbsolute);

                if (mainWindow?.IsActive == tr


 {
        val dX = this.x - x
        val dY = this.y - y
        val dZ = this.z - z
        return dX * dX + dY * dY + dZ * dZ
    }

    fun distance2DToSq(x: Double, z: Double): Double {
        val dX = this.x - x
        val dZ = this.z - z
        return dX * dX + dZ * dZ
    }

    fun distance2DTo(x: Double, z: Double): Double {
        return sqrt(distance2DToSq(x, z))
    }
}
package gg.mineral.bot.api.entity.effect

/**
 * Represents a type of potion and its effect on an entity.
 */
enum class PotionEffectType(val id: Int, val effectName: String, val instant: Boolean) {
    SPEED(1, "Speed", false), SLOW(2, "Slow", false), FAST_DIGGING(3, "Fast Digging", false), SLOW_DIGGING(
        4,
        "Slow Digging", false
    ),
    INCREASE_DAMAGE(5, "Increase Damage", false), INSTANT_HEAL(6, "Heal", true), HARM(
        7,
        "Harm", true
    ),
    JUMP(8, "Jump", false), CONFUSION(9, "Confusion", false), REGENERATION(
        10,
        "Regeneration", false
    ),
    DAMAGE_RESISTANCE(11, "Damage Resistance", false), FIRE_RESISTANCE(
        12, "Fire Resistance",
        false
    ),
    WATER_BREATHING(13, "Water Breathing", false), INVISIBILITY(
        14,
        "Invisibility", false
    ),
    BLINDNESS(15, "Blindness", false), NIGHT_VISION(
        16,
        "Night Vision", false
    ),
    HUNGER(17, "Hunger", false), WEAKNESS(
        18,
        "Weakness", false
    ),
    POISON(19, "Poison", false), WITHER(
        20,
        "Wither", false
    ),
    REGEN(
        21, "Health Boost",
        false
    ),
    ABSORPTION(
        22, "Absorption",
        false
    ),
    SATURATION(
        23, "Saturation",
        true
    );

    companion object {
        @JvmStatic
        fun getById(id: Int): PotionEffectType {
            return entries[id - 1]
        }

        @JvmStatic
        fun getByName(name: String): PotionEffectType? {
            for (effect in entries) if (effect.name.equals(name, ignoreCase = true)) return effect

            return null
        }
    }
}
package gg.mineral.bot.api.math.trajectory.throwable

import gg.mineral.bot.api.math.trajectory.Trajectory
import gg.mineral.bot.api.world.ClientWorld

open class SplashPotionTrajectory(
    world: ClientWorld,
    x: Double,
    y: Double,
    z: Double,
    yaw: Float,
    pitch: Float,
    collisionFunction: Trajectory.CollisionFunction
) :
    ThrowableEntityTrajectory(world, x, y, z, yaw, pitch, collisionFunction) {

    companion object {
        fun fromVelocity(
            world: ClientWorld,
            x: Double,
            y: Double,
            z: Double,
            motionX: Double,
            motionY: Double,
            motionZ: Double,
            collisionFunction: Trajectory.CollisionFunction
        ): SplashPotionTrajectory {
            // Create with dummy yaw/pitch
            val trajectory = SplashPotionTrajectory(world, x, y, z, 0f, 0f, collisionFunction)
            // Override the motion values
            trajectory.motX = motionX.toFloat()
            trajectory.motY = motionY.toFloat()
            trajector


asFunction<int Function(int, int, int, ffi.Pointer<ffi.Void>, ffi.Pointer<ma_allocation_callbacks>, ffi.Pointer<ma_rb>)>(isLeaf: true);

  int ma_rb_init(
    int bufferSizeInBytes,
    ffi.Pointer<ffi.Void> pOptionalPreallocatedBuffer,
    ffi.Pointer<ma_allocation_callbacks> pAllocationCallbacks,
    ffi.Pointer<ma_rb> pRB,
  ) {
    return _ma_rb_init(
      bufferSizeInBytes,
      pOptionalPreallocatedBuffer,
      pAllocationCallbacks,
      pRB,
    );
  }

  late final _ma_rb_initPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(ffi.Size, ffi.Pointer<ffi.Void>, ffi.Pointer<ma_allocation_callbacks>, ffi.Pointer<ma_rb>)>>('ma_rb_init');
  late final _ma_rb_init = _ma_rb_initPtr.asFunction<int Function(int, ffi.Pointer<ffi.Void>, ffi.Pointer<ma_allocation_callbacks>, ffi.Pointer<ma_rb>)>(isLeaf: true);

  void ma_rb_uninit(
    ffi.Pointer<ma_rb> pRB,
  ) {
    return _ma_rb_uninit(
      pRB,
    );
  }

  late final _ma_rb_uninitPtr = _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ma_rb>)>>('ma_rb_uninit');
  late final _ma_rb_uninit = _ma_rb_uninitPtr.asFunction<void Function(ffi.Pointer<ma_rb>)>(isLeaf: true);

  void ma_rb_reset(
    ffi.Pointer<ma_rb> pRB,
  ) {
    return _ma_rb_reset(
      pRB,
    );
  }

  late final _ma_rb_resetPtr = _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ma_rb>)>>('ma_rb_reset');
  late final _ma_rb_reset = _ma_rb_resetPtr.asFunction<void Function(ffi.Pointer<ma_rb>)>(isLeaf: true);

  int ma_rb_acquire_read(
    ffi.Pointer<ma_rb> pRB,
    ffi.Pointer<ffi.Size> pSizeInBytes,
    ffi.Pointer<ffi.Pointer<ffi.Void>> ppBufferOut,
  ) {
    return _ma_rb_acquire_read(
      pRB,
      pSizeInBytes,
      ppBufferOut,
    );
  }

  late final _ma_rb_acquire_readPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(ffi.Pointer<ma_rb>, ffi.Pointer<ffi.Size>, ffi.Pointer<ffi.Pointer<ffi.Void>>)>>('ma_rb_acquire_read');
  late final _ma_rb_acquire_read = _ma_rb_acquire_readPtr.asFunction<int Function(ffi.Pointer<ma_rb>, ffi.Pointer<ffi.Size>, ffi.Pointer<ffi.Pointer<ffi.Void>>)>(isLeaf: true);

  int ma_rb_commit_read(
    ffi.Pointer<ma_rb> pRB,
    int sizeInBytes,
  ) {
    return _ma_rb_commit_read(
      pRB,
      sizeInBytes,
    );
  }

  late final _ma_rb_commit_readPtr = _lookup<ffi.NativeFunction<ffi.Int32 Function(ffi.Pointer<ma_rb>, ffi.Size)>>('ma_rb_commit_read');
  late final _ma_rb_commit_read = _ma_rb_commit_readPtr.asFunction<int Function(ffi.Pointer<ma_rb>, i


44.1-28.8-80.1-81-80.1zM1360.297 838.4c-141.3 0-221.398-84.6-221.398-180.9 0-84.598 47.7-134.098 108.89-165.598-54.9-34.2-89.1-72.9-89.1-138.6 0-105.298 95.4-178.198 204.3-178.198 111.6 0 204.3 54.9 204.3 163.8 0 59.398-30.6 105.298-90 141.298 58.5 27.9 109.8 78.3 109.8 162 0 120.6-96.3 196.198-226.8 196.198zm-10.8-302.398c-41.4 16.2-82.8 57.6-82.8 107.1 0 52.2 34.2 101.7 95.4 101.7 60.3 0 93.6-42.3 93.6-92.7 0-57.6-52.2-89.1-106.2-116.1zm15.3-269.098c-49.5 0-81 30.6-81 74.7 0 52.2 52.2 80.1 92.7 97.2 33.3-15.3 69.3-52.2 69.3-91.8 0-44.1-28.8-80.1-81-80.1z"/></svg>');
}

.bus.ligne389 {
  background-image: url('data:image/svg+xml;utf-8,<svg xmlns="http://www.w3.org/2000/svg" width="1718" height="1000"><path fill="#006CB8" d="M0 0h1718v1000H0z"/><path fill="#FFF" d="M314.502 836.6c-81.9 0-131.4-18.9-182.7-47.7l48.6-98.1c27 20.7 71.1 41.4 125.1 41.4 73.8 0 119.7-39.6 119.7-93.6 0-72.9-55.8-96.3-120.6-96.3h-65.7V437.003h66.6c62.1 0 100.8-30.6 100.8-79.2 0-40.5-30.6-75.6-97.2-75.6-58.5 0-97.2 27.9-117.9 45.9l-44.1-93.6c54.9-36 116.1-56.7 190.8-56.7 129.6 0 203.398 75.6 203.398 160.2 0 65.7-35.1 116.1-102.6 141.3v1.8C508.9 494.6 562 546.8 562 635.9c0 111.6-99.9 200.7-247.498 200.7zm541.798 1.8c-141.3 0-221.4-84.6-221.4-180.9 0-84.598 47.7-134.098 108.9-165.598-54.9-34.2-89.1-72.9-89.1-138.6 0-105.298 95.4-178.198 204.3-178.198 111.598 0 204.297 54.9 204.297 163.8 0 59.398-30.6 105.298-90 141.298 58.5 27.9 109.8 78.3 109.8 162 0 120.6-96.298 196.198-226.798 196.198zm-10.8-302.398c-41.4 16.2-82.8 57.6-82.8 107.1 0 52.2 34.2 101.7 95.4 101.7 60.298 0 93.598-42.3 93.598-92.7 0-57.6-52.2-89.1-106.198-116.1zm15.3-269.098c-49.5 0-81 30.6-81 74.7 0 52.2 52.2 80.1 92.7 97.2 33.3-15.3 69.3-


quare Meters':
        result = (parseInt(value)*10000);
        break;
      case 'Square Kilometers':
        result = (parseInt(value)*10000000000);
        break;
      case 'Acres':
        result = (parseInt(value)*40468564.224);
        break;
      case 'Hectares':
        result = (parseInt(value)*100000000);
        break;
    }
    switch(optionTwo){
      case 'Square Inches':
        this.areaAnswer = (Math.round(((result)/6.4516)*10000)/10000).toString();
        break;
      case 'Square Feet':
        this.areaAnswer = (Math.round(((result)/929.0304)*10000)/10000).toString();
        break;
      case 'Square Yards':
        this.areaAnswer = (Math.round(((result)/8361.2736)*10000)/10000).toString();
        break;
      case 'Square Miles':
        this.areaAnswer = (Math.round(((result)/25899881103.36)*10000)/10000).toString();
        break;
      case 'Square Millimeters':
        this.areaAnswer = (Math.round(((result)/0.01)*10000)/10000).toString();
        break;
      case 'Square Centimeters':
        this.areaAnswer = result;
        break;
      case 'Square Meters':
        this.areaAnswer = (Math.round(((result)/10000)*10000)/10000).toString();
        break;
      case 'Square Kilometers':
        this.areaAnswer = (Math.round(((result)/10000000000)*10000)/10000).toString();
        break;
      case 'Acres':
        this.areaAnswer = (Math.round(((result)/40468564.224)*10000)/10000).toString();
        break;
      case 'Hectares':
        this.areaAnswer = (Math.round(((result)/100000000)*10000)/10000).toString();
        break;
      }
    }
  }

  constructor(){

  }

  ngOnInit() {
    this.areaNumber = '0';
    this.areaAnswer = '0';
    this.areaFirst = 'Square Inches';
    this.areaSecond = 'Square Inches';
  }

}
import { isDate, isMap, isNumber, isString } from 'lodash-es';
import { pickBy } from '../../public-api';
import {
  isA,
  isDateOrString,
  isMapOrString,
  isNumberOrString,
  isStringOr2,
  keyIsA,
  keyIsAorC,
  keyIsAorNumber,
  keyIsC,
  keyIsNumber,
  keyIsString,
  keyIsString2,
  keyIsString3,
} from '../../test-helpers/test-utils';

//
// Array
//

type A = Array<string | number>;
const a = [1, 'b'] as A;
const aOrU = [1, 'b'] as A | undefined;
const aOrN = [1, 'b'] as A | null;

// $ExpectType { [index: number]: string | number; }
pickBy(a, () => true);
// $ExpectType { [index: number]: string | number; }
pickBy(aOrU, () => true);
// $ExpectType { [index: number]: string | number; }
pickBy(aOrN, () => true);

// narrowing

// $ExpectType { [index: number]: string; }
pickBy(a, isString);
// $ExpectType { [index: number]: string; }
pickBy(aOrU, isString);
// $ExpectType { [index: number]: string


_png/ezpQRXtYHibzFofXYA5LgbMA4rP7LgF7HTFL5hibAHGgTswxX3F37t3OonrVstSQ5uWY1ZoWRdUhbsiaoonky06SQ/640?wx_fmt=png&from=appmsg "")

来源｜“量子位”微信公众号

编辑｜风东曾

审核｜秦川原

![](https://mmbiz.qpic.cn/mmbiz_png/ezpQRXtYHibzFofXYA5LgbMA4rP7LgF7HvzY9RFwVhYMkmp5utc7HVXJY3Pe18vxia8Y3fHchL2GsCmM9PlJVcZw/640?wx_fmt=png&from=appmsg "")

#  DocsGPT 远程命令执行漏洞 (CVE-2025-0868)
Superhero  Nday Poc   2025-05-19 08:32

![图片](https://mmbiz.qpic.cn/mmbiz_png/Melo944GVOJECe5vg2C5YWgpyo1D5bCkYN4sZibCVo6EFo0N9b7Kib4I4N6j6Y10tynLOdgov9ibUmaNwW5yeoCbQ/640?wx_fmt=other&from=appmsg&wxfrom=5&wx_lazy=1&wx_co=1&tp=webp "")

![图片](https://mmbiz.qpic.cn/mmbiz_png/Melo944GVOJECe5vg2C5YWgpyo1D5bCkhic5lbbPcpxTLtLccZ04WhwDotW7g2b3zBgZeS5uvFH4dxf0tj0Rutw/640?wx_fmt=other&from=appmsg&wxfrom=5&wx_lazy=1&wx_co=1&tp=webp "")

![图片](https://mmbiz.qpic.cn/mmbiz_png/Melo944GVOJECe5vg2C5YWgpyo1D5bCk524CiapZejYicic1Hf8LPt8qR893A3IP38J3NMmskDZjyqNkShewpibEfA/640?wx_fmt=other&from=appmsg&wxfrom=5&wx_lazy=1&wx_co=1&tp=webp "")

内容仅用于学习交流自查使用，由于传播、利用本公众号所提供的
POC
信息及
POC对应脚本
而造成的任何直接或者间接的后果及损失，均由使用者本人负责，公众号Nday Poc及作者不为此承担任何责任，一旦造成后果请自行承担！

**01**

**漏洞概述**

DocsGPT 中存


  }
}/*
 * Copyright (C) 2015 Square, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package app.cash.copper.flow

import android.database.Cursor
import app.cash.copper.testing.Employee
import app.cash.copper.testing.Employee.Companion.queryOf
import app.cash.copper.testing.NullQuery
import app.cash.turbine.test
import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.hasMessage
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isInstanceOf
import kotlin.time.ExperimentalTime
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.runBlocking
import org.junit.Test

@ExperimentalCoroutinesApi
@ExperimentalTime
class OperatorTest {
  @Test fun mapToOne() = runBlocking {
    flowOf(queryOf("alice", "Alice Allison"))
      .mapToOne(mapper = Employee.MAPPER)
      .test {
        assertThat(awaitItem()).isEqualTo(Employee("alice", "Alice Allison"))
        awaitComplete()
      }
  }

  @Test fun mapToOneWithDefault() = runBlocking {
    flowOf(queryOf("alice", "Alice Allison"))
      .mapToOne(default = Employee("fred", "Fred Frederson"), mapper = Employee.MAPPER)
      .test {
        assertThat(awaitItem()).isEqualTo(Employee("alice", "Alice Allison"))
        awaitComplete()
      }
  }

  @Test fun mapToOneThrowsOnMultipleRows() = runBlocking {
    flowOf(queryOf("alice", "Alice Allison", "bob", "Bob Bobberson"))
      .mapToOne(mapper = Employee.MAPPER)
      .test {
        assertThat(awaitError())
          .isInstanceOf<IllegalStateException>()
          .hasMessage("Cursor returned more than 1 row")
      }
  }

  @Test fun mapToOneEmptyIgnoredWithoutDefault() = runBlocking {
    flowOf(queryOf())
      .mapToOne(mapper = Employee.MAPPER)
      .test {
        awaitComplete()
      }
  }

  @Test fun mapToOneWithDefaultEmpty() = runBlocking {
    flowOf(queryOf())
      .mapToOne(default = Employee("fred", "Fred Frederson"), mapper = Employee.MAPPER)
      .test {
        assertThat(awaitItem()).isEqualTo(Employee("fred", "Fred Frederson"))
        awaitComplete()
      }
  }

  @Test fun mapToOneIgnoresNullCursor() = runBlocking {
    flowOf(NullQuery)
      .mapToOne(mapper = Employee.MAPPER)
      .test {
        awaitComplete()
      }
  }

  @Test fun mapToOneWithDefaultIgnoresNullCursor() = runBlocking {
    flowOf(NullQuery)
      .mapToOne(default = Employee("fred", "Fred Frederson"), mapper = Employee.MAPPER)
      .test {
        awaitComplete()
      }
  }

  @Test fun mapToList() = runBlocking {
    flowOf(queryOf("alice", "Alice Allison", "bob", "Bob Bobberson", "eve", "Eve Evenson"))
      .mapToList(mapper = Employee.MAPPER)
      .test {
        assertThat(awaitItem()).containsExa


NT_NAMESPACE !== "undefined") {
    NS = REACT_APP_BLUEPRINT_NAMESPACE;
}
// modifiers
var ACTIVE = "".concat(NS, "-active");
var ALIGN_LEFT = "".concat(NS, "-align-left");
var ALIGN_RIGHT = "".concat(NS, "-align-right");
var COMPACT = "".concat(NS, "-compact");
var DARK = "".concat(NS, "-dark");
var DISABLED = "".concat(NS, "-disabled");
var FILL = "".concat(NS, "-fill");
var FIXED = "".concat(NS, "-fixed");
var FIXED_TOP = "".concat(NS, "-fixed-top");
var INLINE = "".concat(NS, "-inline");
var INTERACTIVE = "".concat(NS, "-interactive");
var LARGE = "".concat(NS, "-large");
var LOADING = "".concat(NS, "-loading");
var MINIMAL = "".concat(NS, "-minimal");
var OUTLINED = "".concat(NS, "-outlined");
var PADDED = "".concat(NS, "-padded");
var MULTILINE = "".concat(NS, "-multiline");
var READ_ONLY = "".concat(NS, "-read-only");
var ROUND = "".concat(NS, "-round");
var SELECTED = "".concat(NS, "-selected");
var SMALL = "".concat(NS, "-small");
var VERTICAL = "".concat(NS, "-vertical");
var POSITION_TOP = positionClass(_position__WEBPACK_IMPORTED_MODULE_0__.Position.TOP);
var POSITION_BOTTOM = positionClass(_position__WEBPACK_IMPORTED_MODULE_0__.Position.BOTTOM);
var POSITION_LEFT = positionClass(_position__WEBPACK_IMPORTED_MODULE_0__.Position.LEFT);
var POSITION_RIGHT = positionClass(_position__WEBPACK_IMPORTED_MODULE_0__.Position.RIGHT);
var ELEVATION_0 = elevationClass(_elevation__WEBPACK_IMPORTED_MODULE_1__.Elevation.ZERO);
var ELEVATION_1 = elevationClass(_elevation__WEBPACK_IMPORTED_MODULE_1__.Elevation.ONE);
var ELEVATION_2 = elevationClass(_elevation__WEBPACK_IMPORTED_MODULE_1__.Elevation.TWO);
var ELEVATION_3 = elevationClass(_elevation__WEBPACK_IMPORTED_MODULE_1__.Elevation.THREE);
var ELEVATION_4 = elevationClass(_elevation__WEBPACK_IMPORTED_MODULE_1__.Elevation.FOUR);
var INTENT_PRIMARY = intentClass(_intent__WEBPACK_IMPORTED_MODULE_2__.Intent.PRIMARY);
var INTENT_SUCCESS = intentClass(_intent__WEBPACK_IMPORTED_MODULE_2__.Intent.SUCCESS);
var INTENT_WARNING = intentClass(_intent__WEBPACK_IMPORTED_MODULE_2__.Intent.WARNING);
var INTENT_DANGER = intentClass(_intent__WEBPACK_IMPORTED_MODULE_2__.Intent.DANGER);
var FOCUS_DISABLED = "".concat(NS, "-focus-disabled");
var FOCUS_STYLE_MANAGER_IGNORE = "".concat(NS, "-focus-style-manager-ignore");
// text utilities
var UI_TEXT = "".concat(NS, "-ui-text");
var RUNNING_TEXT = "".concat(NS, "-running-text");
var MONOSPACE_TEXT = "".concat(NS, "-monospace-text");
var TEXT_LARGE = "".concat(NS, "-text-large");
var TEXT_SMALL = "".concat(NS, "-text-small");
var TEXT_MUTED = "".concat(NS, "-text-muted");
var TEXT_DISABLED = "".concat(NS, "-text-disabled");
var TEXT_OVERFLOW_ELLIPSIS = "".concat(NS, "-text-overflow-ellipsis");
// textual elements
var BLOCKQUOTE = "".concat(NS, "-blockquote");
var CODE = "".concat(NS, "-code");
var CODE_BLOCK = "".concat(NS, "-code-block");
var HEADING = "".concat(NS, "-heading");
var LIST = "".concat(NS, "-list");
var LIST_UNSTYLED = "".concat(NS, "-list-unstyled");
var RTL = "".concat(NS, "-rtl


package:clean_arcitechture_edu/features/feature_weather/domain/use_cases/get_forecast_weather_use_case.dart'
    as _i7;
import 'package:mockito/mockito.dart' as _i1;

// ignore_for_file: type=lint
// ignore_for_file: avoid_redundant_argument_values
// ignore_for_file: avoid_setters_without_getters
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: implementation_imports
// ignore_for_file: invalid_use_of_visible_for_testing_member
// ignore_for_file: prefer_const_constructors
// ignore_for_file: unnecessary_parenthesis
// ignore_for_file: camel_case_types
// ignore_for_file: subtype_of_sealed_class

class _FakeIWeatherRepository_0 extends _i1.SmartFake
    implements _i2.IWeatherRepository {
  _FakeIWeatherRepository_0(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeDataState_1<T> extends _i1.SmartFake implements _i3.DataState<T> {
  _FakeDataState_1(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

/// A class which mocks [GetCurrentWeatherUseCase].
///
/// See the documentation for Mockito's code generation for more information.
class MockGetCurrentWeatherUseCase extends _i1.Mock
    implements _i4.GetCurrentWeatherUseCase {
  MockGetCurrentWeatherUseCase() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i2.IWeatherRepository get iWeatherReporository => (super.noSuchMethod(
        Invocation.getter(#iWeatherReporository),
        returnValue: _FakeIWeatherRepository_0(
          this,
          Invocation.getter(#iWeatherReporository),
        ),
      ) as _i2.IWeatherRepository);

  @override
  _i5.Future<_i3.DataState<_i6.CurrentCityEntity>> call(String? param) =>
      (super.noSuchMethod(
        Invocation.method(
          #call,
          [param],
        ),
        returnValue: _i5.Future<_i3.DataState<_i6.CurrentCityEntity>>.value(
            _FakeDataState_1<_i6.CurrentCityEntity>(
          this,
          Invocation.method(
            #call,
            [param],
          ),
        )),
      ) as _i5.Future<_i3.DataState<_i6.CurrentCityEntity>>);
}

/// A class which mocks [GetForecastWeatherUseCase].
///
/// See the documentation for Mockito's code generation for more information.
class MockGetForecastWeatherUseCase extends _i1.Mock
    implements _i7.GetForecastWeatherUseCase {
  MockGetForecastWeatherUseCase() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i5.Future<_i3.DataState<_i8.ForecastDaysEntity>> call(
          _i9.ForecastParams? params) =>
      (super.noSuchMethod(
        Invocation.method(
          #call,
          [params],
        ),
        returnValue: _i5.Future<_i3.DataState<_i8.ForecastDaysEntity>>.value(
            _FakeDataState_1<_i8.ForecastDaysEntity>(
          this,
          Invocation.method(
            #call,
            [params],
          ),
        )),
      ) as _i5.Future<_i3.Data


  listas: Lista[] = [];

  constructor() {
    this.cargarData();
    console.log("servicio Creado")
  }

  /* localStorage sólo almacens Strings por lo que convertimos el objeto listas en un JSON */
  actualizarData() {
    localStorage.setItem("data", JSON.stringify(this.listas));
    console.log("datos actualizados")
  }

  /* Como lo que recuperamos es un String, tenemos que hacer un parse de este */
  cargarData() {
    if (localStorage.getItem("data")) this.listas = JSON.parse(localStorage.getItem("data"));
    console.log("datos cargados")
  }

  /* para agregar una lista, la añadimos al array de listas y actualizamos el storage */
  agregarLista(lista: Lista) {
    this.listas.push(lista);
    this.actualizarData();
  }

  /* eliminar lista completa */
  eliminarLista(idx: number) {
    this.listas.splice(idx, 1);
    this.actualizarData();
  }

}
import { useCallback, useState } from 'react';
import useEventListener from './useEventListener';

/**
 * Returns the interior width of the container in pixels.
 *
 * @returns {number} Width of the container in pixels
 */
export default function useContainerWidth(containerId: string): number {
  const [containerWidth, setContainerWidth] = useState(window.innerWidth);

  const getContainerWidth = useCallback(() => {
    const el = document.getElementById(containerId);
    if (!el) {
      setContainerWidth(window.innerWidth);
      return;
    }
    setContainerWidth(el.clientWidth);
  }, [containerId]);

  useEventListener(window, 'resize', getContainerWidth);

  return containerWidth;
}
/* --------------------------------------------------------------------------------------------
 * Copyright (c) Raymond Camden. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for license information.
 * ------------------------------------------------------------------------------------------ */
'use strict';

import {
	IPCMessageReader, IPCMessageWriter,
	createConnection, IConnection,
	TextDocuments, TextDocument, Diagnostic, DiagnosticSeverity,
	InitializeResult
} from 'vscode-languageserver';

let cssLint = require('csslint').CSSLint;

// Create a connection for the server. The connection uses Node's IPC as a transport
let connection: IConnection = createConnection(new IPCMessageReader(process), new IPCMessageWriter(process));

// Create a simple text document manager. The text document manager
// supports full document sync only
let documents: TextDocuments = new TextDocuments();
// Make the text document manager listen on the connection
// for open, change and close text document events
documents.listen(connection);

// After the server has started the client sends an initilize request. The server receives
// in the passed params the rootPath of the workspace plus the client capabilites.
connection.onInitialize((): InitializeResult => {
	return {
		capabilities: {
			// Tell the client that the server works in FULL text document sync mode
			textDocumentSync: documents.syncKind
		}
	}
});

// The content of a text document has changed. This event is emitted
// when the text document first opened or when its content has changed.
documents.onDidChangeContent((change) => {
	validateTextDocument(change.document);
});

// The settings interface describe the server relevant settings part
interface Settings {
	cssLanguageClient: ExampleSettings;
}

// These are the example settings we defined in the client's package.json
//


using System;
using StereoKit;

namespace SKTemplate_UWP_Name
{
	class Program
	{
		static void Main(string[] args)
		{
			// Initialize StereoKit
			SKSettings settings = new SKSettings
			{
				appName      = "SKTemplate_UWP_Name",
				assetsFolder = "Assets",
			};
			if (!SK.Initialize(settings))
				Environment.Exit(1);

			// Create assets used by the app
			Pose  cubePose = new Pose(0,0,-0.5f, Quat.Identity);
			Model cube     = Model.FromMesh(
				Mesh.GenerateRoundedCube(Vec3.One*0.1f, 0.02f),


(this, arg);

  @override
  void transformChildren(Transformer v) {
    if (type != null) {
      type = v.visitDartType(type!);
    }
  }

  @override
  void transformOrRemoveChildren(RemovingTransformer v) {
    if (type != null) {
      DartType newType = v.visitDartType(type!, dummyDartType);
      if (identical(newType, dummyDartType)) {
        type = null;
      } else {
        type = newType;
      }
    }
  }

  @override
  void visitChildren(Visitor v) {
    type?.accept(v);
  }

  @override
  void toTextInternal(AstPrinter printer) {
    if (type != null) {
      type!.toTextInternal(printer);
      printer.write(" ");
    }
    printer.write("_");
  }

  @override
  String toString() {
    return "WildcardPattern(${toStringInternal()})";
  }
}

class AssignedVariablePattern extends Pattern {
  final VariableDeclaration variable;

  /// The type of the expression against which this pattern is matched.
  ///
  /// This is set during inference.
  DartType? matchedValueType;

  /// If `true`, the matched expression must be checked to be of the type
  /// of [variable].
  ///
  /// This is set during inference.
  bool needsCast = false;

  /// If `true`, the assignment occurs in a context where effects can be
  /// observed and must therefore be postponed until the whole pattern has been
  /// evaluated.
  ///
  /// This is used an optimized encoding of pattern assignment. It is sound to
  /// assume that all [AssignedVariablePattern]s have an observable effect.
  ///
  /// For instance
  ///
  ///     class A {
  ///       get b => throw 'foo';
  ///     }
  ///     class B extends A {
  ///       get b => 42;
  ///     }
  ///     method(A a) {
  ///       var b1;
  ///       var b2;
  ///       A(b: b1) = a;
  ///       try {
  ///         A(b: b2) = a;
  ///       } catch (_) {
  ///       }
  ///       print(b1);
  ///       print(b2);
  ///     }
  ///
  /// Here the assignment to `b2` has an observable effect where as `b1` has
  /// not.
  bool hasObservableEffect = true;

  AssignedVariablePattern(this.variable);

  @override
  R accept<R>(PatternVisitor<R> visitor) =>
      visitor.visitAssignedVariablePattern(this);

  @override
  R accept1<R, A>(PatternVisitor1<R, A> visitor, A arg) =>
      visitor.visitAssignedVariablePattern(this, arg);

  @override
  void transformChildren(Transformer v) {}

  @override
  void transformOrRemoveChildren(RemovingTransformer v) {}

  @override
  void visitChildren(Visitor v) {}

  @override
  List<VariableDeclaration> get declaredVariables => const [];

  @override
  String? get variableName => variable.name!;

  @override
  void toTextInternal(AstPrinter printer) {
    printer.write(variable.name!);
  }

  @override
  String toString() {
    return "AssignedVariablePattern(${toStringInternal()})";
  }
}

class MapPattern extends Pattern {
  static const int FlagNeedsCheck = 1 << 0;
  static const int FlagIsNeverPattern = 1 << 1;

  int flags = 0;

  /// The key type arguments as specific in the map pattern syntax.
  DartType? keyType;

  /// The value type arguments as specific in the map pattern syntax.
  DartType? valueType;

  final List<MapPatternEntry> entries;

  /// The required type of the pattern.
  ///
  /// This is the type the matched expression is checked against, if the
  /// [matchedValueType] is not already a subtype of [requiredType].
  ///
  /// This is set during


Y
wG0AT
WG0B
WG0G
WG0I
WG0U
WG0V
WG1I
WG1N
WG2R
WG2S
WG2Z
WG3D
WG3V
WG4P
WG4UM
WG4UM / K2G
WG4Y
WG5J
WG5N
WG5T
WG6M
WG7H
WG7J
WG7Y
WG8AR
WG8I
WG8R
WG8Y
WG9U
WG9V
WH0/K0BBC
WH2AK
WH2AOL
WH2HAO
WH2X
WH4/K6SHJ
WH6AA
WH6AKX
WH6ANH
WH6CC
WH6DGA
WH6DYH
WH6E
WH6E/W8
WH6EBS
WH6EDK
WH6EEY
WH6FC
WH6FM
WH6IO
WH6LE
WH6MC
WH6S
WH7DX
WH7GG
WH7TT
WH7W
WH7Y
WH7ZB
WI0K
WI0S
WI0V
WI0WA
WI1B
WI1G
WI1O
WI1U
WI2E
WI2M
WI2P
WI2P/JA2
WI2T
WI3L
WI3X
WI4L
WI4MPY
WI4P
WI4PER
WI4T
WI4USA
WI5D
WI5H
WI5M
WI5Q
WI6M
WI6T
WI6ZRD
WI7B
WI7N
WI7V
WI9D
WI9TOM
WI9Z
WJ0C
WJ0M
WJ0S
WJ0T
WJ0X
WJ1I
WJ1R
WJ1X
WJ1Z
WJ2D
WJ2K
WJ2R
WJ2T
WJ2X
WJ3A
WJ3F
WJ3P
WJ3R
WJ4HCP
WJ4N
WJ4S
WJ4X
WJ5MH
WJ5O
WJ5TX
WJ6T
WJ7H
WJ7R
WJ8H
WJ9X
WK0C
WK0DX
WK0L
WK1A
WK1J
WK1L
WK1V
WK2C
WK2G
WK2K
WK2S
WK2T
WK2X
WK2Y
WK3C
WK3J
WK3N
WK3O
WK4E
WK4KK
WK4O
WK4P
WK4RC
WK4W
WK4WK
WK4X
WK5DX
WK5F
WK5R
WK5X
WK6A
WK6F
WK6RF
WK6Z
WK7C
WK7K
WK7S
WK7W
WK8A
WK8G
WK8U
WK9H
WK9L
WK9T
WK9X
WL7ADG
WL7AHU
WL7AJN
WL7ARV
WL7BDO
WL7CG
WL7CKX
WL7CLK
WL7CMK
WL7E
WL7E/7
WL7E/KH6
WL7E/W7
WL7E/WH6
WL7GK
WL7N
WL7OU
WL7RV
WL7UL
WL7UQ
WL7VO
WL7X
WM0F
WM0G
WM0L
WM0M
WM1E
WM1K
WM1L
WM2P
WM2U
WM2Z
WM3B
WM3E
WM3L
WM3L/M
WM3O
WM3PEN
WM3T
WM4B
WM4DE
WM4H
WM4J
WM4JS
WM4K
WM4P
WM4Q
WM4R
WM4RB
WM4T
WM4Z
WM5L
WM5O
WM5T
WM5WM/M
WM6DX
WM6V
WM6W
WM7CH


ack());

  static int pack(fb.Builder fbBuilder, FooT? object) {
    if (object == null) return 0;
    return object.pack(fbBuilder);
  }
}

class FooT implements fb.Packable {
  FooPropertiesT? myFoo;

  FooT({
      this.myFoo});

  @override
  int pack(fb.Builder fbBuilder) {
    fbBuilder.startTable(1);
    if (myFoo != null) {
      fbBuilder.addStruct(0, myFoo!.pack(fbBuilder));
    }
    return fbBuilder.endTable();
  }

  @override
  String toString() {
    return 'FooT{myFoo: ${myFoo}}';
  }
}

class _FooReader extends fb.TableReader<Foo> {
  const _FooReader();

  @override
  Foo createObject(fb.BufferContext bc, int offset) =>
    Foo._(bc, offset);
}

class FooBuilder {
  FooBuilder(this.fbBuilder);

  final fb.Builder fbBuilder;

  void begin() {
    fbBuilder.startTable(1);
  }

  int addMyFoo(int offset) {
    fbBuilder.addStruct(0, offset);
    return fbBuilder.offset;
  }

  int finish() {
    return fbBuilder.endTable();
  }
}

class FooObjectBuilder extends fb.ObjectBuilder {
  final FooPropertiesObjectBuilder? _myFoo;

  FooObjectBuilder({
    FooPropertiesObjectBuilder? myFoo,
  })
      : _myFoo = myFoo;

  /// Finish building, and store into the [fbBuilder].
  @override
  int finish(fb.Builder fbBuilder) {
    fbBuilder.startTable(1);
    if (_myFoo != null) {
      fbBuilder.addStruct(0, _myFoo!.finish(fbBuilder));
    }
    return fbBuilder.endTable();
  }

  /// Convenience method to serialize to byte list.
  @override
  Uint8List toBytes([String? fileIdentifier]) {
    final fbBuilder = fb.Builder(deduplicateTables: false);
    fbBuilder.finish(finish(fbBuilder), fileIdentifier);
    return fbBuilder.buffer;
  }
}
class FooProperties {
  FooProperties._(this._bc, this._bcOffset);

  static const fb.Reader<FooProperties> reader = _FooPropertiesReader();

  final fb.BufferContext _bc;
  final int _bcOffset;

  bool get a => const fb.BoolReader().read(_bc, _bcOffset + 0);
  bool get b => const fb.BoolReader().read(_bc, _bcOffset + 1);

  @override
  String toString() {
    return 'FooProperties{a: ${a}, b: ${b}}';
  }

  FooPropertiesT unpack() => FooPropertiesT(
      a: a,
      b: b);

  static int pack(fb.Builder fbBuilder, FooPropertiesT? object) {
    if (object == null) return 0;
    return object.pack(fbBuilder);
  }
}

class FooPropertiesT implements fb.Packable {
  bool a;
  bool b;

  FooPropertiesT({
      required this.a,
      required this.b});

  @override
  int pack(fb.Builder fbBuilder) {
    fbBuilder.putBool(b);
    fbBuilder.putBool(a);
    return fbBuilder.offset;
  }

  @override
  String toString() {
    return 'FooPropertiesT{a: ${a}, b: ${b}}';
  }
}

class _FooPropertiesReader extends fb.StructReader<FooProperties> {
  const _FooPropertiesReader();

  @override
  int get size => 2;

  @override
  FooProperties createObject(fb.BufferContext bc, int offset) =>
    FooProperties._(bc, offset);
}

class FooPropertiesBuilder {
  FooPropertiesBuilder(this.fbBuilder);

  final fb.Builder fbBuilder;

  int finish(bool a, bool b) {
    fbBuilder.putBool(b);
    fbBuilder.putBool(a);
    return fbBuilder.offset;
  }

}

class FooPropertiesObjectBuilder extends fb.ObjectBuilder {


_EXPR = 24
    XML_WITH_SCHEMAS = 25
    XML_WITH_SCHEMATRON = 26
    XML_WITH_MODULES = 27
    XML_WITH_DEBUG = 28
    XML_WITH_DEBUG_MEM = 29
    XML_WITH_DEBUG_RUN = 30
    XML_WITH_ZLIB = 31
    XML_WITH_NONE = 99999 : just to be sure of allocation size
}

Enum xmlParserInputState

Enum xmlParserInputState {
    XML_PARSER_EOF = -1 : nothing is to be parsed
    XML_PARSER_START = 0 : nothing has been parsed
    XML_PARSER_MISC = 1 : Misc* before int subset
    XML_PARSER_PI = 2 : Within a processing instruction
    XML_PARSER_DTD = 3 : within some DTD content
    XML_PARSER_PROLOG = 4 : Misc* after internal subset
    XML_PARSER_COMMENT = 5 : within a comment
    XML_PARSER_START_TAG = 6 : within a start tag
    XML_PARSER_CONTENT = 7 : within the content
    XML_PARSER_CDATA_SECTION = 8 : within a CDATA section
    XML_PARSER_END_TAG = 9 : within a closing tag
    XML_PARSER_ENTITY_DECL = 10 : within an entity declaration
    XML_PARSER_ENTITY_VALUE = 11 : within an entity value in a decl
    XML_PARSER_ATTRIBUTE_VALUE = 12 : within an attribute value
    <a name="XML_PARSER_


dding-top: 8px;margin-bottom: 12px;
}
.questionViewModule .editAppendQuestion-post .editAppendQuestion-formModule .editAppendQuestion-wrap .editAppendQuestionSubmit {
	height: 38px;
	float: left;
	margin-right: 10px;
	position: relative;
	z-index: 2
}
/* 修改问题 */
.questionViewModule .editQuestion{
	margin-left: 10px;margin-right: 10px; margin-top: 40px; margin-bottom: 10px;
}
.questionViewModule .question-wrap .head{
	height: auto;

	padding:15px 10px 5px 10px;
}

.questionViewModule .question-wrap .head .title{
	color:#303133;
	font-size:24px;
	border:none;
	line-height:34px;
	margin:9px 0 18px 0;
}
.questionViewModule .question-wrap .head .questionInfo{
	color: #909399;font-size: 14px;
}
.questionViewModule .question-wrap .head .questionInfo .avatar{
	float: left;
}
.questionViewModule .question-wrap .head .el-badge__content.is-fixed{
	top: 1px;
}
.questionViewModule .question-wrap .head .questionInfo .userName{
	float: left;margin-left: 10px;position: relative;top: 50px;
}
.questionViewModule .question-wrap .head .questionInfo .userName .nickname{
	position: absolute;left: 0px;top: -26px;white-space: nowrap;
}
.questionViewModule_question-wrap_head_questionInfo_userRoleName{
	margin-left:3px;
	white-space:nowrap;
	color:#e2b46e;
	background-color:#f8e7c4;
	border-radius:4px;
	padding:1px 5px;
	font-size: 12px;
	font-style: normal;
	font-weight: normal;
}
.questionViewModule .question-wrap .head .questionInfo .postTime{
	float: left;margin-left: 20px;position: relative;top: 50px;
}
.questionViewModule .question-wrap .head .questionInfo .viewTotal-icon{
	float: left;margin-left: 20px; position: relative;top: 50px;
}
.questionViewModule .question-wrap .head .questionInfo .viewTotal{
	float: left;margin-left: 3px;  position: relative;top: 48px;
}
.questionViewModule .question-wrap .head .questionInfo .answer-icon{
	float: left;margin-left: 20px;position: relative;top: 50px;
}
.questionViewModule .question-wrap .head .questionInfo .answer{
	float: left;margin-left: 3px;  position: relative;top: 48px;
}
.questionViewModule .question-wrap .head .questionInfo .ipAddress{
	float: right;position: relative;top: 48px;
}

.questionViewModule .question-wrap .head .questionInfo .ipAddress .statusTagInfo{
	position: absolute;right:0px; top: -30px;white-space: nowrap;
}
.questionViewModule .question-wrap .head .questionInfo .green-tag{
	display: inline-block;
    font-size: 14px;
    line-height: 14px;
    padding: 6px 8px 6px 8px;
    border-radius: 3px;
    color:#67C23A;
	background-color:#e1f3d8;
	margin-left: 6px;
}
.questionViewModule .question-wrap .head .questionInfo .orange-tag{
	display: inline-block;
    font-size: 14px;
    line-height: 14px;
    padding: 6px 8px 6px 8px;
    border-radius: 3px;
    color:#E6A23C;
	background-color:#faecd8;
	margin-left: 6px;
}
.questionViewModule .question-wrap .head .questionInfo .red-tag{


  end
            end
            if member then colorfn(M) end
        end
    end
end

-- Compute a monochrome bitmap mandelbrot image
local function monomap(width, height)
    local ba, bb = 2 ^ (width % 8 + 1) - 1, 2 ^ (8 - width % 8)
    local scale = fscale / width
    local bitmap = ""
    for y = 0, height - 1 do
        local Ci, b, buf = y * scale - ymax, 1, ""
        for x = 0, width - 1 do
            local Cr = x * scale + xmin
            local Zr, Zi, Zrq, Ziq = Cr, Ci, Cr * Cr, Ci * Ci
            b = b + b
            for _ = 1, M do
                Zi = Zr * Zi * 2 + Ci
                Zr = Zrq - Ziq + Cr
                Ziq = Zi * Zi
                Zrq = Zr * Zr
                if Zrq + Ziq > limit2 then
                    b = b + 1;
                    break
                end
            end
            if b >= 256 then
                buf = buf .. string.char(511 - b);
                b = 1;
            end
        end
        if b ~= 1 then
            buf = buf .. string.char((ba - b) * bb);
        end
        bitmap = bitmap .. buf
    end
    return bitmap
end

local views = {}

local function compute()
    local bmap = monomap(W, H)
    attr = ""
    do_colormap(32, 32, attrcolor)
    bmap = bmap .. attr
    m8.drawit(bmap, check_bitmap_sz)
end

-- main loop
compute()
while true do
    local btn,x,y = m8.waitevent()
    if btn and btn == m8.EVENT.POINTER.LMB_CLICK then
        -- Zoom In by scaling by 2x and re-centering
        table.insert(views, {fscale, xmin, ymax})
        local xc = xmin + (fscale / 256) * x
        local yc = ymax - (fscale / 256) * y
        fscale = fscale / 2
        xmin = xc - fscale / 2
        ymax = yc + fscale / 2
        compute()
    elseif btn and btn == m8.EVENT.POINTER.RMB_CLICK then
        -- Zoom out to previous view
        if #views > 0 then
            local pop = table.remove(views)
            fscale, xmin, ymax = pop[1], pop[2], pop[3]
            compute()
        end
    end
end


3]
× 0085 ÷ 0308 × 0020 ÷ 00A7 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] SECTION SIGN (AI_AL) ÷ [0.3]
× 0085 ÷ 50005 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] <reserved-50005> (XX_AL) ÷ [0.3]
× 0085 ÷ 0020 ÷ 50005 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] SPACE (SP) ÷ [18.0] <reserved-50005> (XX_AL) ÷ [0.3]
× 0085 ÷ 0308 × 50005 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] COMBINING DIAERESIS (CM1_CM) × [28.0] <reserved-50005> (XX_AL) ÷ [0.3]
× 0085 ÷ 0308 × 0020 ÷ 50005 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] <reserved-50005> (XX_AL) ÷ [0.3]
× 0085 ÷ 0E01 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 0085 ÷ 0020 ÷ 0E01 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] SPACE (SP) ÷ [18.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 0085 ÷ 0308 × 0E01 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] COMBINING DIAERESIS (CM1_CM) × [28.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 0085 ÷ 0308 × 0020 ÷ 0E01 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] THAI CHARACTER KO KAI (SA_AL) ÷ [0.3]
× 0085 ÷ 3041 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] HIRAGANA LETTER SMALL A (CJ_NS) ÷ [0.3]
× 0085 ÷ 0020 ÷ 3041 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] SPACE (SP) ÷ [18.0] HIRAGANA LETTER SMALL A (CJ_NS) ÷ [0.3]
× 0085 ÷ 0308 × 3041 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] COMBINING DIAERESIS (CM1_CM) × [21.03] HIRAGANA LETTER SMALL A (CJ_NS) ÷ [0.3]
× 0085 ÷ 0308 × 0020 ÷ 3041 ÷	#  × [0.3] <NEXT LINE (NEL)> (NL) ÷ [5.04] COMBINING DIAERESIS (CM1_CM) × [7.01] SPACE (SP) ÷ [18.0] HIRAGANA LETTER SMALL A (CJ_NS


chain',
    it: 'Prossimo',
    ko: '다음',
    'ja-Hrkt': '次',
  },
  weight: {
    de: 'Gewicht',
    en: 'Weight',
    es: 'Peso',
    fr: 'Poids',
    it: 'Peso',
    ko: '무게',
    'ja-Hrkt': '重量',
  },
};

type Dictionary<T> = { [id: string]: T };

export default Translations;
const executeIfFunction = <T>(f: T | ((key: string) => T), arg: string) =>
  typeof f === "function" ? f(arg) : f
  ;

const toString = (key: string | number) =>
  typeof key === "number" ? key.toString() : key;

export const switchcaseC: <T>(cases: { [id: string]: T }) =>
  ((defaultCase: T) => ((key: string | number) => T)) =
  (cases) => (defaultCase) => (key) =>
    toString(key) in cases ? cases[key] : defaultCase
  ;

export const switchcase: <T>(cases: { [id: string]: T | ((key: string) => T) }) =>
  ((defaultCase: T | ((key: string) => T)) => ((key: string) => T)) =
  (cases) => (defaultCase) => (key) =>
    executeIfFunction(switchcaseC(cases)(defaultCase)(key), key)
  ;

export const extract = <T>(value: T | undefined) => {
  if (value === undefined) {
    throw new Error("Cannot be undefined");
  } else {
    return value;
  }
};
import type { Integration } from "@sentry/types";

import type { Split, UnionConcat } from "../../utils/type";
import type { TrackAppId, TrackEvent } from "../type";
import type { TrackArgs } from "./TrackerProvider";
import { TrackerProvider } from "./TrackerProvider";
import type { ProviderName } from "./utils";

/**
 * Delegate the tracking behaviour to multiple configured sub provider.
 */
export class DelegatingProvider extends TrackerProvider {
  static trackerName = "delegating" as const;

  public inited = false;

  constructor(
    appId: TrackAppId,
    disabled: boolean,
    private readonly providers: TrackerProvider[]
  ) {
    console.log("[Tracker][DelegatingProvider]", { providers });
    super(appId, disabled);
  }

  public static parseQueryString<TQuery extends UnionConcat<ProviderName>>(
    query: `delegating:${TQuery}`
  ): Split<TQuery> {
    return query.split(":")[1]!.split(",") as Split<TQuery>;
  }

  public async init(): Promise<void> {
    await Promise.allSettled(
      this.providers.map(async (provider) => provider.init())
    );
    this.inited = this.providers.every((provider) => provider.inited);
  }

  public async uninit(): Promise<void> {
    await Promise.allSettled(
      this.providers.map(async (provider) => provider.uninit())
    );
    this.inited = this.providers.every((provider) => !provider.inited);
  }

  public getSentryIntegations(): Integration[] {
    return this.providers
      .map((provider) => provider.getSentryIntegations())
      .flat();
  }

  public track<TEvent extends TrackEvent>(...args: TrackArgs<TEvent>): void {
    this.providers.forEach((provider) => {
      provider.track(...(args as Parameters<typeof provider["track"]>));
    });
  }

  public enable(): void {
    this.providers.forEach((provider) => {
      provider.enable();
    });
    super.enable();


ɐi˧˥

15812	喺企	hɐi˧˥ kʰei˧˥

15813	喺屋企hae	hɐi˧˥ ŋʊk˥ kʰei˧˥ hɛ:˧, hɐi˧˥ ʊk˥ kʰei˧˥ hɛ:˧

15814	喺屋企hea	hɐi˧˥ ŋʊk˥ kʰei˧˥ hɛ:˧, hɐi˧˥ ʊk˥ kʰei˧˥ hɛ:˧

15815	喺屋企	hɐi˧˥ ŋʊk˥ kʰei˧˥

15816	喺屋企迆	hɐi˧˥ ŋʊk˥ kʰei˧˥ hɛ:˧, hɐi˧˥ ʊk˥ kʰei˧˥ hɛ:˧

15817	喺度	hɐi˧˥ tou˨

15818	喺晒	hɐi˧˥ sa:i˧

15819	喺處	hɐi˧˥ sy:˧

15820	喺邊度	hɐi˧˥ pi:n˥ tou˨

15821	喻	jy:˨

15822	喼	kɛ:p˥, ki:p˥, kʰɛ:p˥, kʰi:p˥

15823	喼帽	ki:p˥ mou˧˥

15824	喼弗	kʰi:p˥ fi:t˥

15825	喾	kʊk˥

15826	喿	tsʰɔ:˧, tsʰou˧

15827	嗀	hɔ:k˧, hɔ:k˨

15828	嗁	tʰɐi˨˩

15829	嗃	ha:u˥, ha:u˧, hɔ:k˧

15830	嗄	a:˧˥, sa:˧

15831	嗅	tsʰɐu˧, hʊŋ˧<


achine
✅ **No API Keys**: No accounts or authentication required
✅ **Offline Capable**: Works without internet after setup
✅ **No Rate Limits**: Use as much as you want
✅ **No Tracking**: No usage analytics or monitoring
✅ **Your Models**: Downloaded models belong to you forever

## 🛠 **Technical Architecture (For Developers)**

### **8-Model Ensemble System**
```python
Ultimate ML Pipeline:
├── XGBoost (20% weight)        # 99.4% accuracy - Primary model
├── LightGBM (20% weight)       # 97.7% accuracy - Speed + accuracy
├── Random Forest (15% weight)  # 97.6% accuracy - Robust predictions
├── Extra Trees (15% weight)    # 97.3% accuracy - Variance reduction
├── Gradient Boosting (10%)     # 99.0% accuracy - Pattern recognition
├── Ridge Regression (8%)       # 96.7% accuracy - Linear patterns
├── Elastic Net (7%)            # 96.6% accuracy - Feature selection
└── Lasso Regression (5%)       # 96.6% accuracy - Sparse features
```

### **44 Engineered Features**
1. **Price Analysis (5)**: Normalized price, trend, volatility, range, daily range
2. **Volume Analysis (3)**: Volume trend, normalized volume, volume volatility
3. **Technical Indicators (15)**: RSI, MACD (3), Bollinger Bands (2), Stochastic (2), Williams %R, CCI, ATR, OBV, SMA ratios (3)
4. **Moving Averages (4)**: SMA/EMA ratios, trend crossovers
5. **Momentum (3)**: 5-day, 10-day, 20-day momentum
6. **Statistical (4)**: Volatility, skewness, kurtosis, trend strength
7. **Support/Resistance (2)**: Distance to key levels
8. **Sector Intelligence (5)**: Technology, Finance, Healthcare, Energy, Consumer
9. **Market Cap (3)**: Large cap, mid cap, small cap classification

### **Real-Time Features**
- **Market Hours**: NYSE trading hours with timezone awareness
- **Sector Classification**: Automatic industry categorization
- **Model Persistence**: Save/load trained models locally
- **Parallel Processing**: Multi-threaded data collection
- **Error Handling**: Robust fallback mechanisms

## 📈 **Supported Stocks & Markets**

### **162+ Stocks Across All Sectors**
- **Technology**: AAPL, MSFT, GOOGL, AMZN, TSLA, NVDA, META, NFLX
- **Finance**: JPM, BAC, WFC, GS, MS, C, USB, PNC, TFC, COF
- **Healthcare**: JNJ, PFE, UNH, ABBV, MRK, TMO, ABT, LLY, MDT
- **Energy**: XOM, CVX, COP, EOG, SLB, PSX, VLO, MPC, OXY
- **Consumer**: WMT, HD, PG, KO, PEP, COST, NKE, SBUX, MCD
- **ETFs**: SPY, QQQ, IWM, VTI, VOO, VEA, VWO, BND, AGG

### **Prediction Capabilities**
- **Timeframe**: 1-30 days ahead
- **Accuracy**: 97.9% ensemble accuracy
- **Confidence**: 50-98% confidence scores
- **Market Timing**: Business day awareness
- **Sector Analysis**: Industry-specific insights

## 🔧 **Advanced Configuration**

### **Model Training Options**
```bash
# Full dataset training (recommended for best accuracy)
python ara_fast.py AAPL --retrain --period 2y

# Quick training (faster, slightly lower accuracy)
python ara_fast.py AAPL --retrain --period 6mo

# Verbose output (see all training details)
python ara_fast.py AAPL --retrain --verbose
```


Page < lastPage

        if (currentPage == 1) {
            latestIds = emptyList()
        }

        val projectIds = result
            .map { it.projectId!! }
            .distinct()
            .filterNot { latestIds.contains(it) }

        latestIds = latestIds + projectIds

        if (projectIds.isEmpty()) {
            return MangasPage(emptyList(), hasNextPage)
        }

        val projectsApiUrl = "$baseUrl/$API_BASE_PATH/projetos".toHttpUrl().newBuilder()
            .addQueryParameter("include", projectIds.joinToString(","))
            .addQueryParameter("per_page", projectIds.size.toString())
            .addQueryParameter("orderby", "include")
            .addQueryParameter("_fields", DEFAULT_FIELDS)
            .toString()
        val projectsRequest = GET(projectsApiUrl, apiHeaders)
        val projectsResponse = client.newCall(projectsRequest).execute()
        val projectsResult = projectsResponse.parseAs<List<TaoSectProjectDto>>()

        val projectList = projectsResult.map(::popularMangaFromObject)

        return MangasPage(projectList, hasNextPage)
    }

    override fun searchMangaRequest(page: Int, query: String, filters: FilterList): Request {
        if (query.startsWith(SLUG_PREFIX_SEARCH) && query.removePrefix(SLUG_PREFIX_SEARCH).isNotBlank()) {
            return mangaDetailsRequest(query.removePrefix(SLUG_PREFIX_SEARCH))
        }

        val apiUrl = "$baseUrl/$API_BASE_PATH/projetos".toHttpUrl().newBuilder()
            .addQueryParameter("page", page.toString())
            .addQueryParameter("per_page", PROJECTS_PER_PAGE.toString())
            .addQueryParameter("_fields", DEFAULT_FIELDS)

        if (query.isNotEmpty()) {
            apiUrl.addQueryParameter("search", query)
        }

        filters.filterIsInstance<QueryParameterFilter>()
            .forEach { it.toQueryParameter(apiUrl, query) }

        return GET(apiUrl.toString(), apiHeaders)
    }

    override fun searchMangaParse(response: Response): MangasPage = popularMangaParse(response)

    override fun getMangaUrl(manga: SManga): String = baseUrl + manga.url

    override fun mangaDetailsRequest(manga: SManga): Request = mangaDetailsRequest(manga.url)

    private fun mangaDetailsRequest(mangaUrl: String): Request {
        val projectSlug = mangaUrl
            .substringAfterLast("projeto/")
            .substringBefore("/")

        val apiUrl = "$baseUrl/$API_BASE_PATH/projetos".toHttpUrl().newBuilder()
            .addQueryParameter("per_page", "1")
            .addQueryParameter("slug", projectSlug)
            .addQueryParameter("_fields", "title,informacoes,content,thumbnail,link")
            .toString()

        return GET(apiUrl, apiHeaders)
    }

    override fun mangaDetailsParse(response: Response): SManga {
        val result = response.parseAs<List<TaoSectProjectDto>>()

        if (result.isEmpty()) {
            throw Exception(PROJECT_NOT_FOUND)
        }

        val project = result[0]

        return SManga.create().apply {
            title = Parser.unescapeEntities(project.title!!.rendered, true)
            author = project.info!!.script
            artist = project.info.art
            genre = project.info.genres.joinToString { it.name }
            status = project.info.status!!.name.toStatus()
            description = Jsoup.parse(project.content!!.rendered).text() +
                "\n\nTítulo original: " + project.info.originalTitle +
                "\nSerialização: " + project.info.serialization
            thumbnail_url = project.thumbnail
        }
    }


// 演示读写文件

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "esp_flash.h"
#include "esp_vfs.h"
#include "esp_vfs_fat.h"
#include "esp_system.h"

static const char *TAG = "FAT";

// Handle of the wear levelling library instance
static wl_handle_t s_wl_handle = WL_INVALID_HANDLE;

// Mount path for the partition
const char *base_path = "/fatfs_image";

// Mount FATFS partition
static bool mount_fatfs(const char* partition_label)
{
    ESP_LOGI(TAG, "Mounting FAT filesystem");
    const esp_vfs_fat_mount_config_t mount_config = {
            .max_files = 4,
            .format_if_mount_failed = true,
            .allocation_unit_size = CONFIG_WL_SECTOR_SIZE
    };
    esp_err_t err = esp_vfs_fat_spiflash_mount_rw_wl(base_path, partition_label, &mount_config, &s_wl_handle);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "Failed to mount FATFS (%s)", esp_err_to_name(err));
        return false;
    }
    return true;
}

void app_main(void)
{
  	const char *partition_label = "storage";
    // Initialize FAT FS in the partition
    if (!mount_fatfs(partition_label)) {
        return;
    }

    // Print FAT FS size information
    uint64_t bytes_total, bytes_free;
    esp_vfs_fat_info(base_path, &bytes_total, &bytes_free);
    ESP_LOGI(TAG, "FAT FS: %" PRIu64 " kB total, %" PRIu64 " kB free", bytes_total / 1024, bytes_free / 1024);

    Create a file in FAT FS
    ESP_LOGI(TAG, "Opening file");
    FILE *f = fopen("/fatfs_image/hello.txt", "wb");
    if (f == NULL) {
        ESP_LOGE(TAG, "Failed to open file for writing");
        return;
    }
    fprintf(f, "fat文件系统测试 %s\n", "hollo world!");
    fclose(f);
    ESP_LOGI(TAG, "File written");

    // Open file for reading
    ESP_LOGI(TAG, "Reading file");
    f = fopen("/fatfs_image/hello.txt", "rb");
    if (f == NULL) {
        ESP_LOGE(TAG, "Failed to open file for reading");
        return;
    }
    char line[128];
    fgets(line, sizeof(line), f);
    fclose(f);
    // strip newline
    char *pos = strchr(line, '\n');
    if (pos) {
        *pos = '\0';
    }
    ESP_LOGI(TAG, "Read from file: '%s'", line);
	// Unmount FAT FS
	ESP_LOGI(TAG, "Unmounting FAT filesystem");
	esp_err_t unmount_err = esp_vfs_fat_spiflash_unmount_rw_wl(base_path, s_wl_handle);
	if (unmount_err != ESP_OK) {
		ESP_LOGE(TAG, "Failed to unmount FATFS (%s)", esp_err_to_name(unmount_err));
		return;
	}
}


l to md.digestLength.
 *
 * @return a KDF2 API object.
 */
forge.kem.kdf2 = function(md, digestLength) {
  _createKDF(this, md, 1, digestLength || md.digestLength);
};

/**
 * Creates a KDF1 or KDF2 API object.
 *
 * @param md the hash API to use.
 * @param counterStart the starting index for the counter.
 * @param digestLength the digest length to use.
 *
 * @return the KDF API object.
 */
function _createKDF(kdf, md, counterStart, digestLength) {
  /**
   * Generate a key of the specified length.
   *
   * @param x the binary-encoded byte string to generate a key from.
   * @param length the number of bytes to generate (the size of the key).
   *
   * @return the key as a binary-encoded string.
   */
  kdf.generate = function(x, length) {
    var key = new forge.util.ByteBuffer();

    // run counter from counterStart to ceil(length / Hash.len)
    var k = Math.ceil(length / digestLength) + counterStart;

    var c = new forge.util.ByteBuffer();
    for(var i = counterStart; i < k; ++i) {
      // I2OSP(i, 4): convert counter to an octet string of 4 octets
      c.putInt32(i);

      // digest 'x' and the counter and add the result to the key
      md.start();
      md.update(x + c.getBytes());
      var hash = md.digest();
      key.putBytes(hash.getBytes(digestLength));
    }

    // truncate to the correct key length
    key.truncate(key.length() - length);
    return key.getBytes();
  };
}

} // end module implementation

/* ########## Begin module wrapper ########## */
var name = 'kem';
if(typeof define !== 'function') {
  // NodeJS -> AMD
  if(typeof module === 'object' && module.exports) {
    var nodeJS = true;
    define = function(ids, factory) {
      factory(require, module);
    };
  } else {
    // <script>
    if(typeof forge === 'undefined') {
      forge = {};
    }
    return initModule(forge);
  }
}
// AMD
var deps;
var defineFunc = function(require, module) {
  module.exports = function(forge) {
    var mods = deps.map(function(dep) {
      return require(dep);
    }).concat(initModule);
    // handle circular dependencies
    forge = forge || {};
    forge.defined = forge.defined || {};
    if(forge.defined[name]) {
      return forge[name];
    }
    forge.defined[name] = true;
    for(var i = 0; i < mods.length; ++i) {
      mods[i](forge);
    }
    return forge[name];
  };
};
var tmpDefine = define;
define = function(ids, factory) {
  deps = (typeof ids === 'string') ? factory.slice(2) : ids.slice(2);
  if(nodeJS) {
    delete define;
    return tmpDefine.apply(null, Array.prototype.slice.call(arguments, 0));
  }
  define = tmpDefine;
  return define.apply(null, Array.prototype.slice.call(arguments, 0));
};
define('js/kem',['require', 'module', './util','./random','./jsbn'], function() {
  defineFunc.apply(null, Array.prototype.slice.call(arguments, 0));
});
})();

/**
 * Cross-browser support for logging in a web application.
 *
 * @author David I. Lehn <dlehn@digitalbazaar.com>
 *
 * Copyright (c) 2008-2013 Digital Bazaar, Inc.
 */
(function() {
/* ########## Begin module implementation ########## */
function initModule(forge) {

/* LOG API */
forge.log = forge.log || {};

/**
 * Application logging system.
 *
 * Each


 {
		if strings.ContainsRune(example, '\n') {
			example = strings.TrimRight(example, "\n")
			example = strings.Join(strings.Split(example, "\n"), "\n  ")
			example = fmt.Sprintf("\nExample:\n  %s", example)
		} else {
			example = fmt.Sprintf("\nExample: %q", example)
		}
	}
	return example
}

// MakeValues returns a Mapping with all default values for the Helm chart.
func MakeValues(settings ExportSettings) helm.Node {
	values := MakeBasicValues()
	env := helm.NewMapping()
	secrets := helm.NewMapping()
	generated := helm.NewMapping()

	for name, cv := range model.MakeMapOfVariables(settings.RoleManifest) {
		if strings.HasPrefix(name, "KUBE_SIZING_") || cv.CVOptions.Type == model.CVTypeEnv {
			continue
		}
		// Immutable secrets that are generated cannot be overridden by the user
		// and any default value would always be ignored.
		if cv.CVOptions.Immutable && cv.Type != "" {
			continue
		}

		var value interface{}
		if !cv.CVOptions.Secret || cv.Type == "" {
			var ok bool
			if ok, value = cv.Value(); !ok {
				value = nil
			}
		}
		comment := cv.CVOptions.Description
		if cv.CVOptions.Secret {
			thisValue := "This value"
			if cv.Type != "" {
				comment += "\n" + thisValue + " uses a generated default."
				thisValue = "It"
			}
			if cv.CVOptions.Immutable {
				comment += "\n" + thisValue + " is immutable and must not be changed once set."
			}
			if cv.Type == "certificate" && !cv.CVOptions.IsCA {
				comment += "\nThis certificate uses the "
				if cv.CVOptions.RoleName != "" {
					comment += " role name " + strconv.Quote(cv.CVOptions.RoleName)
					if cv.CVOptions.AltNames != nil {
						comment += " and the additional"
					}
				} else if cv.CVOptions.AltNames == nil {
					comment += " name " + strconv.Quote(util.ConvertNameToKey(name))
				}
				if cv.CVOptions.AltNames != nil {
					if len(cv.CVOptions.AltNames) == 1 {
						comment += " name " + strconv.Quote(cv.CVOptions.AltNames[0])
					} else {
						comment += " names " + util.WordList(util.QuoteList(cv.CVOptions.AltNames), "and")
					}
				}
				comment += "."
			}
			comment += formattedExample(cv.CVOptions.Example)
			if cv.Type == "" {
				secrets.Add(name, helm.NewNode(value, helm.Comment(comment)))
			} else {
				generated.Add(name, helm.NewNode(value, helm.Comment(comment)))
			}
		} else {
			comment += formattedExample(cv.CVOptions.Example)
			env.Add(name, helm.NewNode(value, helm.Comment(comment)))
		}
	}
	secrets.Sort()
	secrets.Merge(generated.Sort())
	values.Add("secrets", secrets.Sort())
	values.Add("env", env.Sort())

	sizing := helm.NewMapping()
	sizing.Set(helm.Comment(strings.Join(strings.Fields(`
		The sizing section contains configuration to change each individual instance
		group.  Due to limitations on the allowable names, any dashes ("-") in the
		instance group names are replaced with underscores ("_").
	`), " ")))
	for _, instanceGroup := range settings.RoleManifest.InstanceGroups {
		if instanceGroup.Run.FlightStage == model.FlightStageManual {
			continue
		}

		entry := helm.NewMapping()

		var comment string
		it := fmt.Sprintf("The %s instance group", makeV


 )
	{
		m_flProgress = event->GetFloat( "progress" );

		// so we don't interp back to the start position on reset
		if ( event->GetBool( "reset" ) )
		{
			m_flProgressHistory.ClearHistory();
		}

		m_flProgressHistory.NoteChanged( gpGlobals->curtime, false );
	}
	else if ( FStrEq( eventName, "escort_speed" ) )
	{
		int iSpeedLevel = event->GetInt( "speed" );
		int nPlayers = event->GetInt( "players" );

		m_pSpeedBackwards->SetVisible( iSpeedLevel < 0 );

		bool bShowPlayers = ( iSpeedLevel > 0 ) && ( nPlayers > 0 );
		m_pCapPlayerImage->SetVisible( bShowPlayers );
		m_pCapNumPlayers->SetVisible( bShowPlayers );
		m_pEscortItemPanel->SetDialogVariable( "numcappers", nPlayers );

		// make sure the point isn't being marked as blocked when we're showing players or moving backwards
		if ( bShowPlayers || ( iSpeedLevel < 0 ) )
		{
			m_pBlocked->SetVisible( false );
		}

		m_pEscortItemPanel->InvalidateLayout();

		if ( iSpeedLevel > 0 && m_iSpeedLevel == 0 )
		{
			m_bShowSwoop = true;
		}

		m_iSpeedLevel = iSpeedLevel;
	}
	if ( FStrEq( eventName, "escort_recede" ) )
	{
		m_flRecedeTime = event->GetFloat( "recedetime" );
	}
	else if ( FStrEq( eventName, "controlpoint_initialized" ) )
	{
		UpdateCPImages();
	}
	else if ( FStrEq( eventName, "controlpoint_updateimages" ) )
	{
		// Update the images of our control point icons
		int iIndex = event->GetInt( "index" );

		bool bIsAnyCapBlocked = false;

		// Only invalidate the specified cap point
		// unless iIndex is -1, then do them all
		for (int i = 0; i < m_Icons.Count(); i++)
		{
			if ( iIndex != -1 && m_Icons[i]->GetCapIndex() != iIndex )
				continue;

			m_Icons[i]->SetForceOpaqueImages( !m_bMultipleTrains && ( m_nNumHills > 0 ) );
			m_Icons[i]->UpdateImage();

			if ( ObjectiveResource()->IsCPBlocked( m_Icons[i]->GetCapIndex() ) )
			{
				bIsAnyCapBlocked = true;
			}
		}

		// update our teardrop status
		UpdateStatusTeardropFor( m_iCurrentCP );

		// Assume that there is only one cap area linked to the escort item
		m_pBlocked->SetVisible( bIsAnyCapBlocked );
	}
	else if ( FStrEq( "controlpoint_updatecapping", eventName ) )
	{
		// Update the capping status of our control point icons
		int iIndex = event->GetInt( "index" );
		UpdateStatusTeardropFor( iIndex );
		return;
	}
	else if ( FStrEq( "controlpoint_starttouch", eventName ) )
	{
		int iPlayer = event->GetInt( "player" );
		if ( pPlayer && iPlayer == pPlayer->entindex() )
		{
			m_iCurrentCP = event->GetInt( "area" );
			UpdateStatusTeardropFor( m_iCurrentCP );
		}
	}
	else if ( FStrEq( "controlpoint_endtouch", eventName ) )
	{
		int iPlayer = event->GetInt( "player" );
		if ( pPlayer && iPlayer == pPlayer->entindex() )
		{
			m_iCurrentCP = -1;
			UpdateStatusTeardropFor( m_iCurrentCP );


ult = []

            for pb in playbooks:
                command = 'ansible-playbook {}/{}'.format(self.PLAYBOOK_PATH, pb['name'])
                self.logger.debug("Command to be executed: {}".format(command))
                return_code, stdout, stderr = await util_ee.local_async_exec(command)
                stdoutput = stdout.decode("utf-8")  # .split('\n')
                stderror = stderr.decode("utf-8")
                self.logger.debug("return_code: {}, stdout: {}, stderr: {}".format(return_code, stdoutput, stderror))
                # remove non json stdout lines (e.g., from the ansible pause modules)
                start_position = stdoutput.find('{')
                json_string = stdoutput[start_position:]
                # json_string = "".join(stdoutput).replace('\\', '\\\\')
                # json.loads(json_string)
                result.append({'playbook': pb['name'], 'stdout': json.loads(json_string), 'stderr': stderror})

            # generate post method to the nfvcl
            post_message = {
                'result': result,
                'action_id': action_id,
                'nsd_id': nsd_id,
                'vnfd_id': vnfd_id,
                'blue_id': blue_id
            }
            self.logger.info("POST message body: {}".format(json.dumps(post_message)))
            headers = {'Content-type': 'application/json', 'Accept': 'text/plain'}
            r = requests.post(post_url, json=post_message, headers=headers)
            self.logger.info("POST message: {} - {}".format(r.status_code, r.text))

            yield "OK", "Action ID: {}".format(post_message['action_id'])
        except Exception as e:
            self.logger.error(traceback.format_tb(e.__traceback__))
            self.logger.error("Error executing flexops: {}".format(repr(e)))
            yield "ERROR", str(e) + "\n".join(traceback.format_tb(e.__traceback__))

    @staticmethod
    def _check_required_params(params, required_params):
        for required_param in required_params:
            if required_param not in params:
                raise VnfException("Missing required param: {}".format(required_param))


px}._740w{padding-left:6px}._22ss._740w ._5-cj{visibility:hidden}._6ani ._5ya{border-radius:5px;box-shadow:0 0 0 1px #dddfe2}._5ya._k17{animation:removeAdWithAnimation 2s 1 linear forwards}@keyframes removeAdWithAnimation{0%{margin-right:24px;opacity:1;width:250px}50%{margin-right:24px;opacity:0;width:150px}80%{margin-right:0;opacity:0;width:50px}90%{margin-right:0;opacity:0;width:20px}100%{margin-right:0;opacity:0;width:0}}._5ya:hover{box-shadow:0 0 0 1px rgba(0, 0, 0, .15) inset, 0 1px 4px rgba(0, 0, 0, .1)}._6ani ._5ya:hover{box-shadow:0 0 0 1px #dddfe2}._5eut._28d8{height:72px;padding:6px 8px}._5eut{height:54px;padding:6px 8px}._6ani ._5eut{background-color:#f5f6f7;border-bottom-left-radius:5px;border-bottom-right-radius:5px}._3oy2 ._5eut{height:36px;padding:12px 12px 12px 12px}._6ani ._6anj,._6ani ._6anj>a{align-items:center;display:flex;flex-direction:row;height:100%}._6ani ._6anj>a{flex-grow:1}._6ani ._6ank{padding-left:15px}._g5g{border:1px solid rgba(0, 0, 0, .1);border-width:0 0 1px;height:298px;margin:1px 0 0 1px;overflow:hidden;text-align:center;width:298px}._5fj_{background-image:url(../img/../img/r/4kBJPt0lBTM.png);background-repeat:no-repeat;background-size:53px 60px;height:41px;left:122px;margin:0 auto;padding-bottom:13px;padding-left:6px;padding-right:6px;padding-top:6px;position:absolute;top:89px;width:41px}._wp7{height:300px;overflow:hidden;text-align:center;width:300px}._g5g a{height:298px;width:298px}._6ani ._wp7,._6ani ._g5g{border-top-left-radius:5px;border-top-right-radius:5px}._6ani ._g5g{margin:0;width:300px}._5ya:hover ._g5g{border-color:rgba(0, 0, 0, .15)}._5ya:hover ._wp7{border-color:rgba(0, 0, 0, .15)}._kvn{height:300px;margin:-1px 0 0 -1px;width:300px}._4fs3{position:relative}._4fs4{background-color:#000;border-radius:4px;color:#fff;font-size:12px;font-weight:bold;opacity:.7;position:absolute;right:12px;top:12px}._2wtx{border:1px solid;border-color:#EBEDF0 #e9ebee #ccd0d5;bottom:0;left:0;position:absolute;right:0;top:0}._6ani ._2wtx{border:none;border-radius:5px}._6ani ._2wtx:hover{background-color:rgba(29, 33, 41, .04)}._4ozq{position:relative}._4ozq ._1ig7{bottom:-4px;position:relative;z-index:2}._6ani ._4ozq ._2wtx{border-top-left-radius:0;border-top-right-radiu


build",
): ScriptBuildStep {
	return bashNodeScript {
		name = "Upload $slug source maps to Sentry"
		scriptContent = """
			rm -rf code code.zip

			# Downloads the latest release build for the plugin.
			wget "%teamcity.serverUrl%/repository/download/calypso_calypso_WPComPlugins_Build_Plugins/$buildTag.tcbuildtag/$slug.zip?guest=1&branch=trunk" -O ./code.zip

			unzip -q ./code.zip -d ./code
			cd code

			# Upload the .js and .js.map files to Sentry for the given release.
			sentry-cli releases files %SENTRY_RELEASE_NAME% upload-sourcemaps . \
					--auth-token %SENTRY_AUTH_TOKEN% \
					--org a8c \
					--project wpcom-gutenberg-wp-admin \
					--url-prefix "$wpcomURL"
		"""
	}
}
package com.willfp.ecopets

import com.willfp.ecopets.api.EcoPetsAPI
import com.willfp.ecopets.pets.Pet
import com.willfp.ecopets.pets.activePet
import com.willfp.ecopets.pets.getPetLevel
import com.willfp.ecopets.pets.getPetProgress
import com.willfp.ecopets.pets.getPetXP
import com.willfp.ecopets.pets.getPetXPRequired
import com.willfp.ecopets.pets.givePetExperience
import com.willfp.ecopets.pets.hasPet
import org.bukkit.OfflinePlayer
import org.bukkit.entity.Player

internal object EcoPetsAPIImpl : EcoPetsAPI {
    override fun hasPet(player: OfflinePlayer, pet: Pet) = player.hasPet(pet)

    override fun getActivePet(player: OfflinePlayer): Pet? = player.activePet

    override fun setActivePet(player: OfflinePlayer, pet: Pet?) {
        player.activePet = pet
    }

    override fun getPetLevel(player: OfflinePlayer, pet: Pet) = player.getPetLevel(pet)

    override fun givePetExperience(player: Player, pet: Pet, amount: Double) =
        player.givePetExperience(pet, amount)

    override fun givePetExperience(player: Player, pet: Pet, amount: Double, applyMultipliers: Boolean) =
        player.givePetExperience(pet, amount, noMultiply = !applyMultipliers)

    override fun getPetProgress(player: OfflinePlayer, pet: Pet) =
        player.getPetProgress(pet)

    override fun getPetXPRequired(player: OfflinePlayer, pet: Pet) =
        player.getPetXPRequired(pet)

    override fun getPetXP(player: OfflinePlayer, pet: Pet) =
        player.getPetXP(pet)
}
package com.willfp.ecopets.commands

import com.willfp.eco.core.EcoPlugin
import com.willfp.eco.core.command.impl.Subcommand
import com.willfp.eco.util.StringUtils
import com.willfp.eco.util.savedDisplayName
import com.willfp.eco.util.toNiceString
import com.willfp.ecopets.pets.Pets
import com.willfp.ecopets.pets.activePet
import com.willfp.ecopets.pets.givePetExperience
import com.willfp.ecopets.pets.hasPet
import org.bukkit.Bukkit
import org.bukkit.command.CommandSender
import org.bukkit.entity.Player
import org.bukkit.util.StringUtil

class CommandGiveCurrentXP(plugin: EcoPlugin) : Subcommand(plugin, "givecurrentxp", "ecopets.command.givecurrentxp", false) {
    override fun onExecute(sender: CommandSender, args: List<String>) {
        if (args.isEmpty()) {
            sender.sendMessage(plugin.langYml.getMessage("needs-player"))
            return
        }

        if (args.size == 1) {
            sender.sendMessage(plugin.langYml.getMessage("needs-amount"))
            return
        }

        val playerName = args[0]

        val player = Bukkit.getPlayer(playe


            {% include 'blog/tags/base_right.html' %}

{% endblock %}{% extends 'blog/base.html' %}
{% load static %}
{% load humanize %}
{% load comment_tags blog_tags %}

{% block head_title %}个人信息推送{% endblock %}

{% block top-file %}
    <link href="{% static 'comment/css/notification.css' %}?v=20190704" rel="stylesheet">
{% endblock %}

{% block base_content %}

                {% get_notifications user is_read as notifications %}

                    {% for each in notifications|slice:":30" %}

                            <time class="cbp_tmtime" datetime="{{ each.create_date }}">
                                {{ each.create_date|date:"Y/m/d" }}
                                {{ each.create_date|date:"H:i" }}
                            </time>

                                {% if each.tag == "comment" %}

                                        {{ each.create_p }} 在

                                            {{ each.comment.belong.title }} 中@了你，并评论道：

{{ each.comment.content|my_slice:':130' }}

                                {% elif each.tag == "system" %}

                                        【系统通知】{{ each.title }}

{{ each.content|safe }}

                                {% endif %}
                                {% if not each.is_read %}

                                        <button class="btn btn-success float-right f-16" data-id="{{ each.id }}"
                                                data-csrf="{{ csrf_token }}" data-tag="{{ each.tag }}"
                                                data-url="{% url 'comment:mark_to_read' %}">标为已读
                                        </button>

                                {% else %}

                                        <button class="btn btn-danger float-right f-16" data-id="{{ each.id }}"
                                                data-csrf="{{ csrf_token }}" data-tag="{{ each.tag }}"
                                                data-url="{% url 'comment:mark_to_delete' %}">删除信息


4(a0)		// load pixels
	sw	t0,0*4(a2)		// store pixels
	lw	t0,1*4(a0)		// load pixels
	sw	t0,1*4(a2)		// store pixels
	lw	t0,2*4(a0)		// load pixels
	sw	t0,2*4(a2)		// store pixels
	lw	t0,3*4(a0)		// load pixels
	sw	t0,3*4(a2)		// store pixels
	lw	t0,4*4(a0)		// load pixels
	sw	t0,4*4(a2)		// store pixels
	lw	t0,5*4(a0)		// load pixels
	sw	t0,5*4(a2)		// store pixels
	lw	t0,6*4(a0)		// load pixels
	sw	t0,6*4(a2)		// store pixels
	lw	t0,7*4(a0)		// load pixels
	sw	t0,7*4(a2)		// store pixels

	// 2nd tile
	h3.bextmi t0,a7,8,8		// T0 <- tile index
	mul	t0,t0,a5		// T0 <- tile_index * delta
	add	a0,t0,a4		// A0 <- tile pointer
	lw	t0,0*4(a0)		// load pixels
	sw	t0,8*4(a2)		// store pixels
	lw	t0,1*4(a0)		// load pixels
	sw	t0,9*4(a2)		// store pixels
	lw	t0,2*4(a0)		// load pixels
	sw	t0,10*4(a2)		// store pixels
	lw	t0,3*4(a0)		// load pixels
	sw	t0,11*4(a2)		// store pixels
	lw	t0,4*4(a0)		// load pixels
	sw	t0,12*4(a2)		// store pixels
	lw	t0,5*4(a0)		// load pixels
	sw	t0,13*4(a2)		// store pixels
	lw	t0,6*4(a0)		// load pixels
	sw	t0,14*4(a2)		// store pixels
	lw	t0,7*4(a0)		// load pixels
	sw	t0,15*4(a2)		// store pixels

	// 3rd tile
	h3.bextmi t0,a7,16,8		// T0 <- tile index
	mul	t0,t0,a5		// T0 <- tile_index * delta
	add	a0,t0,a4		// A0 <- tile pointer
	lw	t0,0*4(a0)		// load pixels
	sw	t0,16*4(a2)		// store pixels
	lw	t0,1*4(a0)		// load pixels
	sw	t0,17*4(a2)		// store pixels
	lw	t0,2*4(a0)		// load pixels
	sw	t0,18*4(a2)		// store pixels
	lw	t0,3*4(a0)		// load pixels
	sw	t0,19*4(a2)		// store pixels
	lw	t0,4*4(a0)		// load pixels
	sw	t0,20*4(a2)		// store pixels
	lw	t0,5*4(a0)		// load pixels
	sw	t0,21*4(a2)		// store pixels
	lw	t0,6*4(a0)		// load pixels
	sw	t0,22*4(a2)		// store pixels
	lw	t0,7*4(a0)		// load pixels
	sw	t0,23*4(a2)		// stor