.addConstr(iterator[cur_tuple][0] >= 0)
                model.addConstr(iterator[cur_tuple][1] >= iterator[cur_tuple][0] / M)

# ------------------------------- 定义约束条件 ------------------------------- #

# 约束1
# 舱室容量限制，第i舱室第j层的货量不能超过设定的值
for i in range(1, compartments_num + 1):
    for j in range(1, floors_in_each_compartment_num + 1):
        cur_room_sum = gp.quicksum(
            iterator[i, j, s, d][0]
            for s in range(1, loading_sites_num + 1)
            for d in range(1, destination_num + 1)
        )
        # 添加约束
        model.addConstr(cur_room_sum <= pair2storage(i, j))

# 约束2
# 装载地供应限制，所有从装载地loading_sites_num装载的纸浆包数量不能超过设定值
for s in range(1, loading_sites_num + 1):
    cur_s_load_sum = gp.quicksum(
        iterator[i, j, s, d][0]
        for i in range(1, compartments_num + 1)
        for j in range(1, floors_in_each_compartment_num + 1)
        for d in range(1, destination_num + 1)
    )
    # 添加约束
    model.addConstr(cur_s_load_sum <= src2provide(s))

# 约束3
# 送达地需求限制，所有送达地d的需求必须满足到货量要等于需求
for s in range(1, loading_sites_num + 1):
    for d in range(1, destination_num + 1):
        cur_get_num = gp.quicksum(
            iterator[i, j, s, d][0]
            for i in range(1, compartments_num + 1)
            for j in range(1, floors_in_each_compartment_num + 1)
        )
        # 添加约束
        model.addConstr(cur_get_num == pair2demand(s, d))

# 约束4
# 装卸限制，由于船舶是从装载地 1 出发，顺序经过装载地 1、2、3、送达地 A、B、C、D
for i in range(1, compartments_num + 1):
    for j in range(1, floors_in_each_compartment_num + 1):
        for s in range(1, loading_sites_num + 1):
            # 控制装载顺序
            the_goods_from_s = model.addVar(vtype=GRB.BINARY)
            model.addConstrs(
                the_goods_from_s >= iterator[(i, j, s, d_)][1] / M
                for d_ in range(1, destination_num + 1)
            )
            the_goods_load_behind_s = model.addVar(vtype=GRB.BINARY)
            model.addConstrs(
                the_goods_load_behind_s >= iterator[(i, j_, s_, d_)][1] / M
                for j_ in range(1, j)
                for s_ in range(s + 1, loading_sites_num + 1)
                for d_ in range(1, destination_num + 1)
            )
            model.addGenConstrIndicator(
                the_goods_from_s, 1, the_goods_load_behind_s == 0
            )
        for d in range(1, destination_num + 1):
            # 控制卸货顺序
            the_goods_to_d = model.addVar(vtype=GRB.BINARY)
            model.addConstrs(
                the_goods_to_d >= iterator[(i, j, s_, d)][1] / M
                for s_ in range(1, loading_sites_num + 1)
            )
            the_goods_behind_to_d = model.addVar(vtype=GRB.BINARY)
            model.addConstrs(
                the_goods_behind_to_d >= iterator[(i, j_, s_, d_)][1] / M
                for j_ in range(1, j)
                for s_ in range(1, loading_sites_num + 1)
                for d_ in range(1, d)
            )
            model.addGenConstrIndicator(the_goods_to_d, 1, the_goods_behind_to_d == 0)

# 约束5
# 在每个装载或卸载地时，不能同时打开 2、3 舱和 4、5 舱
for s in range(1, loading_sites_num + 1):
    goods_load_from_s_c2 = model.addVar(vtype=GRB.BINARY)
    goods_load_from_s_c3 = model.addVar(vtype=GRB.BINARY)
    goods_load_from_s_c4 = model.addVar(vtype=GRB.BINARY)
    goods_load_from_s_c5 = model.addVar(vtype=GRB.BINARY)
    model.addConstrs(
        goods_load_from_s_c2 >= iterator[2, j, s, d_][0] / M
        for j in range(1, floors_in_each_compartment_num + 1)
        for d_ in range(1, destination_num + 1)
    )
    model.addConstrs(
        goods_load_from_s_c3 >= iterator[3, j, s, d_][0] / M
        for j in range(1, floors_in_each_compartment_num + 1)
        for d_ in range(1, destination_num + 1)
    )
    model.addConstrs(
        goods_load_from_s_c4 >= iterator[4, j, s, d_][0] / M
        for j in range(1, floors_in_each_compartment_num + 1)
        for d_ in range(1, destination_num + 1)
    )
    model.addConstrs(
        goods_load_from_s_c5 >= iterator[5, j, s, d_][0] / M
        for j in range(1, floors_in_each_compartment_num + 1)
        for d_ in range(1, destination_num + 1)
    )
    # 添加约束
    model.addConstr(goods_load_from_s_c2 + goods_load_from_s_c3 <= 1)
    model.addConstr(goods_load_from_s_c4 + goods_load_from_s_c5 <= 1)

for d in range(1, destination_num + 1):
    goods_deload_to_d_c2 = model.addVar(vtype=GRB.BINARY)
    goods_deload_to_d_c3 = model.addVar(vtype=GRB.BINARY)
    goods_deload_to_d_c4 = model.addVar(vtype=GRB.BINARY)
    goods_del


uat = pose_dist.sample_pose(random_state)
      axisangle_samp = tr.quat_to_axisangle(quat)

      self.assertTrue(np.all(np.nonzero(pos)[0] == np.nonzero(pos_sd)[0]))
      self.assertTrue(
          np.all(np.nonzero(axisangle_samp)[0] == np.nonzero(rot_sd)[0]))

  def testWeightedDiscretePoseDistribution(self):
    """Test weighted samples of a discrete set of poses."""
    rs = np.random.RandomState(0)
    base_dist = pose_distribution.UniformPoseDistribution(
        np.ones(6) * -1, np.ones(6) * 1
    )
    poses = [base_dist.sample_pose(rs) for _ in range(3)]

    dist = pose_distribution.WeightedDiscretePoseDistribution(poses, [1, 10, 0])
    sampled_poses = [dist.sample_pose(rs) for _ in range(100)]

    is_close = lambda a, b: np.allclose(np.concatenate(a), np.concatenate(b))
    num_times_sampled = [
        np.sum([is_close(o, p) for p in sampled_poses]) for o in poses
    ]

    # Poses 0 and 1 should be sampled with nonzero probability.
    self.assertGreater(num_times_sampled[0], 0)
    self.assertGreater(num_times_sampled[1], 0)

    # Poses 2 should never be sampled.
    self.assertEqual(num_times_sampled[2], 0)

    # The second pose should be higher probability than the first.
    self.assertGreater(num_times_sampled[1], num_times_sampled[0])

if __name__ == '__main__':
  absltest.main()


          continue;
                }
                match self.grid.get(&next) {
                | Some(Block::Wall) => continue,
                | Some(Block::Door(_)) if next != end => continue,
                | Some(Block::Door(_)) => queue.push_back((next, dis + 1)),
                | _ => queue.push_back((next, dis + 1)),
                }
            }
        }

        None
    }

    fn collapse(&self) -> HashMap<Collapsed, Vec<(Collapsed, i64)>> {
        let mut all = self.grid.iter()
            .filter_map(|(&pos, &block)| match block {
                Block::Key(k) => Some((pos, Collapsed::Key(k))),
                Block::Door(d) => Some((pos, Collapsed::Door(d))),
                _ => None,
            })
            .collect::<Vec<_>>();

        for (i, entrance) in self.entrances.iter().copied().enumerate() {
            all.push((entrance, Collapsed::Start(i as u8)));
        }

        let mut collapsed = HashMap::new();

        for i in 0..all.len() {
            for j in i + 1..all.len() {
                let (pos_a, a) = all[i];
                let (pos_b, b) = all[j];
                if let Some(dis) = self.bfs(pos_a, pos_b) {
                    collapsed.entry(a)
                        .or_insert_with(Vec::new)
                        .push((b, dis));
                    collapsed.entry(b)
                        .or_insert_with(Vec::new)
                        .push((a, dis));
                }
            }
        }

        collapsed
    }

    /// ```text
    /// ...    @#@
    /// .@. => ###
    /// ...    @#@
    /// ```
    fn split(&mut self) {
        let p = self.entrances[0];
        self.grid.insert(p, Block::Wall);
        self.grid.insert(Pos { x: p.x + 1, y: p.y }, Block::Wall);
        self.grid.insert(Pos { x: p.x - 1, y: p.y }, Block::Wall);
        self.grid.insert(Pos { x: p.x, y: p.y + 1 }, Block::Wall);
        self.grid.insert(Pos { x: p.x, y: p.y - 1 }, Block::Wall);
        self.entrances.clear();
        self.entrances.push(Pos { x: p.x - 1, y: p.y - 1 });
        self.entrances.push(Pos { x: p.x + 1, y: p.y - 1 });
        self.entrances.push(Pos { x: p.x - 1, y: p.y + 1 });
        self.entrances.push(Pos { x: p.x + 1, y: p.y + 1 });
    }
}

impl Solution for ManyWorldsInterpretation {
    fn one(self) -> i64 {
        let count = self.grid.values()
            .filter(|b| b.is_key())
            .count();

        let full = (0b1 << count) - 1;

        let collapsed = self.collapse();
        let mut queue = PriorityQueue::new();
        let mut seen = HashSet::new();

        queue.push((Collapsed::Start(0), KeySet::empty()), cmp::Reverse(0));

        while let Some(((node, set), cmp::Reverse(dis))) = queue.pop() {

            if set.0 == full {
                return dis;
            }

            seen.insert((node, set));

            for &(next, delta) in &collapsed[&node] {
                let next_set = match next {
                | Collapsed::Start(_) => continue,
                | Collapsed::Door(d) if !set.contains(d) => continue,
                | Collapsed::Door(_) =>


.slds-text-title_bold {
  font-size: 0.875rem;
  font-weight: 700;
}
.slds-line-height_reset {
  line-height: 1;
}
.slds-text-color_default {
  color: #080707;
}
.slds-text-color_weak {
  color: #3e3e3c;
}
.slds-text-color_error {
  color: #c23934;
}
.slds-text-color_destructive {
  color: #c23934;
}
.slds-text-color_success {
  color: #027e46;
}
.slds-text-color_inverse {
  color: white;
}
.slds-text-color_inverse-weak {
  color: #b0adab;
}
.slds-text-align_left {
  text-align: left;
}
.slds-text-align_center {
  text-align: center;
}
.slds-text-align_right {
  text-align: right;
}
.slds-text-longform h1,
.slds-text-longform h2,
.slds-text-longform h3,
.slds-text-longform p,
.slds-text-longform ul,
.slds-text-longform ol,
.slds-text-longform dl,
.slds-text-longform img {
  margin-bottom: 0.75rem;
}
.slds-text-longform ul {
  margin-left: 1.5rem;
  list-style: disc;
}
.slds-text-longform ul ul {
  list-style: circle;
}
.slds-text-longform ul ul ul {
  list-style: square;
}
.slds-text-longform ol {
  margin-left: 1.5rem;
  list-style: decimal;
}
.slds-text-longform ol ol {
  list-style: lower-alpha;
}
.slds-text-longform ol ol ol {
  list-style: lower-roman;
}
.slds-text-longform .slds-video {
  display: block;
  max-width: 100%;
}
.slds-text-longform .slds-video.slds-video_center {
  margin: 0 auto;
}
.slds-text-longform .slds-video.slds-video_right {
  margin: 0 0 0 auto;
}
.slds-text-font_monospace {
  font-family: Consolas, Menlo, Monaco, Courier, monospace;
}
.slds-color__text_gray-1 {
  color: white !important;
}
.slds-color__text_gray-2 {
  color: #fafaf9 !important;
}
.slds-color__text_gray-3 {
  color: #f3f2f2 !important;
}
.slds-color__text_gray-4 {
  color: #ecebea !important;
}
.slds-color__text_gray-5 {
  color: #dddbda !important;
}
.slds-color__text_gray-6 {
  color: #c9c7c5 !important;
}
.slds-color__text_gray-7 {
  color: #b0adab !important;
}
.slds-color__text_gray-8 {
  color: #969492 !important;
}
.slds-color__text_gray-9 {
  color: #706e6b !important;
}
.slds-color__text_gray-10 {
  color: #514f4d !important;
}
.slds-color__text_gray-11 {
  color: #3e3e3c !important;
}
.slds-color__text_gray-12 {
  color: #2b2826 !important;
}
.slds-color


: columns,
            where: whereId
        });

        // ACCESSING STATIC METHOD FROM CHILD INSTANCE (FALLBACK TO PARENT)
        //@ts-ignore
        return this.from(dbResult);
    }

    static from<T>(this: new () => T, dbResult): T
    {
        if (!dbResult) return null;

        let entity = new this();

        //@ts-ignore
        entity.preGet();

        Object.keys(dbResult).forEach(columnKey =>
        {
            // ACCESSING STATIC PROPERTY FROM CHILD INSTANCE (FALLBACK TO PARENT)
            //@ts-ignore
            let columnInfo = this.entityData.columns[columnKey] as ColumnInfo;
            let dbValue = dbResult[columnKey];

            let value = columnInfo.fromDb(dbValue, columnInfo.Type);

            entity[columnKey] = value;
        });

        //@ts-ignore
        entity.postGet();

        return entity;
    }
}import { expect } from 'chai'

import { toLiteral } from '../../src/autofix/toLiteral'

describe('toLiteral', () => {
  it('transforms primitive values', () => {
    expect(toLiteral('abc')).to.be.deep.eq('"abc"')
    expect(toLiteral(5)).to.be.deep.eq('5')
    expect(toLiteral(true)).to.be.deep.eq('true')
    expect(toLiteral(null)).to.be.deep.eq('null')
    expect(toLiteral(undefined)).to.be.deep.eq('undefined')
  })

  it('transforms objects', () => {
    const input = {
      abc: 5,
      nested: {
        c: 5,
        a: null,
      },
    }

    expect(toLiteral(input)).to.be.deep.eq('{"abc":5,"nested":{"a":null,"c":5,},}')
  })

  it('transforms arrays', () => {
    const input = [
      {
        abc: 5,
        nested: {
          a: null,
        },
      },
      'a string',
    ]

    expect(toLiteral(input)).to.be.deep.eq('[{"abc":5,"nested":{"a":null,},},"a string"]')
  })

  it('transforms custom classes', () => {
    class DummyClass {
      constructor(readonly value1: number) {}
    }
    const input = new DummyClass(5)

    expect(toLiteral(input)).to.be.deep.eq('expect.a(DummyClass)')
  })

  it('transforms errors to error matcher', () => {
    const input = new Error('Goodbye cruel world!')

    expect(toLiteral(input)).to.be.deep.eq('expect.error("Goodbye cruel world!")')
  })

  it.skip('prettifies output')
})
const twoSum = (nums: Array<number>, target: number): Array<number> => {
  for (let i = 0; i < nums.length; i++) {
    const diff = target - nums[i];
    const index = nums.indexOf(diff);
    if (index > -1 && index !== i) return [i, index];
  }
};

const sample = [3, 2, 4];

console.log(twoSum(sample, 6));
import libLgt from './lib-light';
import libRGB from './lib-rgb-filter';
import libTr from './lib-transition';

const lib = <any>{};

/**
 * Transform is the main entry point for this lib.
 */

 /**
 * Takes a string and returns all words with
 *   first letter Cap and spaces replace underscores
 */
const capAndSplit = (word: string) => {
  return word.split('_').map(wd => wd.charAt(0).toUpperCase() + wd.slice(1)).join(' ');
};
/**
 * optionValues is to return an array of options for the rgbFilter Select.
 * Form: [{ key: 'red_filter', value: 'red_filter', text: 'Red filter' }]
 */

lib.categories = {
  lights: libLgt.lights,
  rgbs: libRGB.rgbFilter,
  transitions: libTr.transitions,
};

 /** For checking if an optin exists,


patch that lacking previous dependencies

cherry-ignore: PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE is not it 10.2

cherry-ignore: drop whitespace fix

cherry-ignore: reject a15088338eb

get-pick-list.sh: Require explicit "10.2" for nominating stable patches

mesa: fix make tarballs

Update VERSION to 10.2.7

Ian Romanick (1):

mesa: Handle uninitialized textures like other textures in get_tex_level_parameter_image

Ilia Mirkin (9):

nouveau: make sure to invalidate any vbo state as well

nouveau: don't keep stale pointer to free'd data

nvc0/ir: avoid infinite recursion when finding first uses of tex

nv50: zero out unbound samplers

nvc0: don't make 1d staging textures linear

nv50/ir: avoid creating instructions that can't be emitted

nv50: set the miptree address when clearing bo's in vp2 init

nv50: mt address may not be the underlying bo's start address

nv50: attach the buffer bo to the miptree structures

Jan Vesely (1):

gallivm: Fix build with latest LLVM

José Fonseca (1):

mesa: Move declaration to top of block.

Kenneth Graunke (3):

i965/vec4: Set NoMask for GS_OPCODE_SET_VERTEX_COUNT on Gen8+.

i965/vec4: Respect ir->force_writemask_all in Gen8 code generation.

i965/clip: Fix brw_clip_unfilled.c/compute_offset's assembly.

Marek Olšák (3):

r600g: fix constant buffer fetches

radeonsi: save scissor state and sample mask for u_blitter

glsl_to_tgsi: allocate and enlarge arrays for temporaries on demand

Paulo Sergio Travaglia (2):

android: gallium/radeon: attempt to fix the android build

android: egl/main: resolve radeon linking issues

Pekka Paalanen (1):

egl_dri2: fix EXT_image_dma_buf_import fds

Robert Bragg (1):

meta: save and restore swizzle for _GenerateMipmap

Tom Stellard (7):

radeon/compute: Fix reported values for MAX_GLOBAL_SIZE and MAX_MEM_ALLOC_SIZE

radeonsi/compute: Update reference counts for buffers in si_set_global_binding()

radeonsi/compute: Call si_pm4_free_state() after emitting compute state

clover: Flush the command queue in clReleaseCommandQueue


                                25.5f, 0.0f,  62.5f, 50.0f, 50.0f,  25.0f, 75.0f};

        glPathCommandsCHROMIUM(path, 5, kCommands, 14, GL_FLOAT, kCoords);
        glPathParameterfCHROMIUM(path, GL_PATH_STROKE_WIDTH_CHROMIUM, 5.0f);
        glPathParameterfCHROMIUM(path, GL_PATH_MITER_LIMIT_CHROMIUM, 1.0f);
        glPathParameterfCHROMIUM(path, GL_PATH_STROKE_BOUND_CHROMIUM, .02f);
        glPathParameteriCHROMIUM(path, GL_PATH_JOIN_STYLE_CHROMIUM, GL_ROUND_CHROMIUM);
        glPathParameteriCHROMIUM(path, GL_PATH_END_CAPS_CHROMIUM, GL_SQUARE_CHROMIUM);
        ASSERT_GL_NO_ERROR();
    }

    void verifyTestPatternFill(GLfloat flx, GLfloat fly)
    {
        static const GLint kFillCoords[]  = {55, 54, 50, 28, 66, 63};
        static const angle::GLColor kBlue = {0, 0, 255, 255};

        GLint x = static_cast<GLint>(flx);
        GLint y = static_cast<GLint>(fly);

        for (size_t i = 0; i < 6; i += 2)
        {
            GLint fx = kFillCoords[i];
            GLint fy = kFillCoords[i + 1];
            EXPECT_TRUE(CheckPixels(x + fx, y + fy, 1, 1, 0, kBlue));
        }
    }
    void verifyTestPatternBg(GLfloat fx, GLfloat fy)
    {
        static const GLint kBackgroundCoords[]     = {80, 80, 20, 20, 90, 1};
        static const angle::GLColor kExpectedColor = {0, 0, 0, 0};

        GLint x = static_cast<GLint>(fx);
        GLint y = static_cast<GLint>(fy);

        for (size_t i = 0; i < 6; i += 2)
        {
            GLint bx = kBackgroundCoords[i];
            GLint by = kBackgroundCoords[i + 1];
            EXPECT_TRUE(CheckPixels(x + bx, y + by, 1, 1, 0, kExpectedColor));
        }
    }

    void verifyTestPatternStroke(GLfloat fx, GLfloat fy)
    {
        GLint x = static_cast<GLint>(fx);
        GLint y = static_cast<GLint>(fy);

        // Inside the stroke we should have green.
        static const angle::GLColor kGreen = {0, 255, 0, 255};
        EXPECT_TRUE(CheckPixels(x + 50, y + 53, 1, 1, 0, kGreen));
        EXPECT_TRUE(CheckPixels(x + 26, y + 76, 1, 1, 0, kGreen));

        // Outside the path we should have black.
        static const angle::GLColor black = {0, 0, 0, 0};
        EXPECT_TRUE(CheckPixels(x + 10, y + 10, 1, 1, 0, black));
        EXPECT_TRUE(CheckPixels(x + 80, y + 80, 1, 1, 0, black));
    }

    GLuint mColorLoc;
};

// Tests that basic path rendering functions work.
TEST_P(CHROMIUMPathRenderingDrawTest, TestPathRendering)
{
    if (!isApplicable())
        return;

    static const float kBlue[]  = {0.0f, 0.0f, 1.0f, 1.0f};
    static const float kGreen[] = {0.0f, 1.0f, 0.0f, 1.0f};

    setupStateForTestPattern();

    GLuint path = glGenPathsCHROMIUM(1);
    setupPathStateForTestPattern(path);

    // Do the stencil fill, cover fill, stencil stroke, cover stroke
    // in unconventional order:
    // 1) stencil the stroke in stencil high bit
    // 2) stencil the fill in low bits
    // 3) cover the fill
    // 4) cover the stroke
    // This is done to check that glPathStencilFunc works, eg the mask
    // goes through. Stencil func is not tested ATM, for simplicity.


1to16}, %zmm19, %zmm19 {%k2}

// CHECK: vpmaxsd 256(%rdx){1to16}, %zmm19, %zmm19 {%k2} {z}
// CHECK: encoding: [0x62,0xe2,0x65,0xd2,0x3d,0x5a,0x40]
vpmaxsd 256(%rdx){1to16}, %zmm19, %zmm19 {%k2} {z}

// CHECK: vpmaxsd 256(%rdx,%rax){1to16}, %zmm19, %zmm19
// CHECK: encoding: [0x62,0xe2,0x65,0x50,0x3d,0x5c,0x02,0x40]
vpmaxsd 256(%rdx,%rax){1to16}, %zmm19, %zmm19

// CHECK: vpmaxsd 256(%rdx,%rax){1to16}, %zmm19, %zmm19 {%k2}
// CHECK: encoding: [0x62,0xe2,0x65,0x52,0x3d,0x5c,0x02,0x40]
vpmaxsd 256(%rdx,%rax){1to16}, %zmm19, %zmm19 {%k2}

// CHECK: vpmaxsd 256(%rdx,%rax){1to16}, %zmm19, %zmm19 {%k2} {z}
// CHECK: encoding: [0x62,0xe2,0x65,0xd2,0x3d,0x5c,0x02,0x40]
vpmaxsd 256(%rdx,%rax){1to16}, %zmm19, %zmm19 {%k2} {z}

// CHECK: vpmaxsd 256(%rdx,%rax,4){1to16}, %zmm19, %zmm19
// CHECK: encoding: [0x62,0xe2,0x65,0x50,0x3d,0x5c,0x82,0x40]
vpmaxsd 256(%rdx,%rax,4){1to16}, %zmm19, %zmm19

// CHECK: vpmaxsd -256(%rdx,%rax,4){1to16}, %zmm19, %zmm19
// CHECK: encoding: [0x62,0xe2,0x65,0x50,0x3d,0x5c,0x82,0xc0]
vpmaxsd -256(%rdx,%rax,4){1to16}, %zmm19, %zmm19

// CHECK: vpmaxsd 256(%rdx,%rax,4){1to16}, %zmm19, %zmm19 {%k2}
// CHECK: encoding: [0x62,0xe2,0x65,0x52,0x3d,0x5c,0x82,0x40]
vpmaxsd 256(%rdx,%rax,4){1to16}, %zmm19, %zmm19 {%k2}

// CHECK: vpmaxsd -256(%rdx,%rax,4){1to16}, %zmm19, %zmm19 {%k2}
// CHECK: encoding: [0x62,0xe2,0x65,0x52,0x3d,0x5c,0x82,0xc0]
vpmaxsd -256(%rdx,%rax,4){1to16}, %zmm19, %zmm19 {%k2}

// CHECK: vpmaxsd 256(%rdx,%rax,4){1to16}, %zmm19, %zmm19 {%k2} {z}
// CHECK: encoding: [0x62,0xe2,0x65,0xd2,0x3d,0x5c,0x82,0x40]
vpmaxsd 256(%rdx,%rax,4){1to16}, %zmm19, %zmm19 {%k2} {z}

// CHECK: vpmaxsd -256(%rdx,%rax,4){1to16}, %zmm19, %zmm


local b = require 'map_gen.shared.builders'
return b.decompress({
height = 64,
width = 64,
data = {
    {1,64,},
    {1,64,},
    {1,64,},
    {1,30,2,4,1,30,},
    {1,29,2,6,1,29,},
    {1,28,2,8,1,28,},
    {1,28,2,9,1,27,},
    {1,27,2,10,1,27,},
    {1,27,2,11,1,26,},
    {1,26,2,12,1,26,},
    {1,25,2,14,1,25,},
    {1,25,2,14,1,25,},
    {1,24,2,16,1,24,},
    {1,24,2,16,1,24,},
    {1,23,2,18,1,23,},
    {1,23,2,19,1,22,},
    {1,22,2,20,1,22,},
    {1,21,2,22,1,21,},
    {1,21,2,22,1,21,},
    {1,20,2,24,1,20,},
    {1,20,2,24,1,20,},
    {1,19,2,26,1,19,},
    {1,19,2,27,1,18,},
    {1,18,2,28,1,18,},
    {1,17,2,6,1,15,2,9,1,17,},
    {1,17,2,5,1,17,2,2,1,2,2,4,1,17,},
    {1,16,2,6,1,17,2,3,1,2,2,4,1,16,},
    {1,16,2,6,1,17,2,3,1,3,2,3,1,16,},
    {1,15,2,7,1,3,2,11,1,3,2,4,1,3,2,3,1,15,},
    {1,15,2,7,1,3,2,11,1,3,2,4,1,4,2,2,1,15,},
    {1,14,2,8,1,3,2,11,1,3,2,4,1,4,2,3,1,14,},
    {1,14,2,8,1,3,2,11,1,3,2,4,1,4,2,4,1,13,},
    {1,13,2,9,1,3,2,11,1,3,2,5,1,3,2,4,1,13,},
    {1,12,2,10,


_misses": 0
            }
            return stats
        except Exception as e:
            logger.error(f"获取性能统计失败: {str(e)}")
            return {}

    def optimize(self):
        """优化缓存"""
        try:
            # 清理过期缓存
            now = datetime.now()
            for key, cache_data in list(self.memory_cache.items()):
                if now >= cache_data["expire"]:
                    del self.memory_cache[key]

            for file in os.listdir(self.cache_dir):
                if file.endswith(".json"):
                    cache_file = os.path.join(self.cache_dir, file)
                    with open(cache_file, "r", encoding="utf-8") as f:
                        cache_data = json.load(f)
                        expire_time = datetime.fromisoformat(cache_data["expire"])
                        if now >= expire_time:
                            os.remove(cache_file)
        except Exception as e:
            logger.error(f"优化缓存失败: {str(e)}")


ing get image => $_getSZ(5);
  @$pb.TagNumber(6)
  set image($core.String v) { $_setString(5, v); }
  @$pb.TagNumber(6)
  $core.bool hasImage() => $_has(5);
  @$pb.TagNumber(6)
  void clearImage() => clearField(6);

  @$pb.TagNumber(7)
  $core.String get title => $_getSZ(6);
  @$pb.TagNumber(7)
  set title($core.String v) { $_setString(6, v); }
  @$pb.TagNumber(7)
  $core.bool hasTitle() => $_has(6);
  @$pb.TagNumber(7)
  void clearTitle() => clearField(7);

  @$pb.TagNumber(8)
  $core.String get name => $_getSZ(7);
  @$pb.TagNumber(8)
  set name($core.String v) { $_setString(7, v); }
  @$pb.TagNumber(8)
  $core.bool hasName() => $_has(7);
  @$pb.TagNumber(8)
  void clearName() => clearField(8);
}

class bangumi_latest_ extends $pb.GeneratedMessage {
  factory bangumi_latest_({
    $core.Iterable<bangumi_latest_item_>? data,
  }) {
    final $result = create();
    if (data != null) {
      $result.data.addAll(data);
    }
    return $result;
  }
  bangumi_latest_._() : super();
  factory bangumi_latest_.fromBuffer($core.List<$core.int> i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromBuffer(i, r);
  factory bangumi_latest_.fromJson($core.String i, [$pb.ExtensionRegistry r = $pb.ExtensionRegistry.EMPTY]) => create()..mergeFromJson(i, r);

  static final $pb.BuilderInfo _i = $pb.BuilderInfo(_omitMessageNames ? '' : '_bangumi_latest', package: const $pb.PackageName(_omitMessageNames ? '' : 'bangumi'), createEmptyInstance: create)
    ..pc<bangumi_latest_item_>(1, _omitFieldNames ? '' : 'data', $pb.PbFieldType.PM, subBuilder: bangumi_latest_item_.create)
    ..hasRequiredFields = false
  ;

  @$core.Deprecated(
  'Using this can add significant overhead to your binary. '
  'Use [GeneratedMessageGenericExtensions.deepCopy] instead. '
  'Will be removed in next major version')
  bangumi_latest_ clone() => bangumi_latest_()..mergeFromMessage(this);
  @$core.Deprecated(
  'Using this can add significant overhead to your binary. '
  'Use [GeneratedMessageGenericExtensions.rebuild] instead. '
  'Will be removed in next major version')
  bangumi_latest_ copyWith(void Function(bangumi_latest_) updates) => super.copyWith((message) => updates(message as bangumi_latest_)) as bangumi_latest_;

  $pb.BuilderInfo get info_ => _i;

  @$core.pragma('dart2js:noInline')
  static bangumi_latest_ create() => bangumi_latest_._();
  bangumi_latest_ createEmptyInstance() => create();
  static $pb.PbList<bangumi_latest_> createRepeated() => $pb.PbList<bangumi_latest_>();
  @$core.pragma('dart2js:noInline')
  static bangumi_latest_ getDefault() => _defaultInstance ??= $pb.GeneratedMessage.$_defaultFor<bangumi_latest_>(create);
  static bangumi_latest_? _defaultInstance;

  @$pb


 default:
                  Consume(TOK_Y, "'Y' expected");
                  A->AddrModeSet = AM65_DIR_IND_Y;
                  break;
            }
         }
         else {
            // (adr)
            switch (CPU) {
               case CPU_4510:
                  A->AddrModeSet = AM65_ABS_IND;
                  break;

               case CPU_45GS02:
                  A->AddrModeSet = AM65_ABS_IND | AM65_DIR_IND;
                  break;

               default:
                  A->AddrModeSet =
                      AM65_ABS_IND | AM65_ABS_IND_LONG | AM65_DIR_IND;
                  break;
            }
         }
      }
   }
   else if (CurTok.Tok == TOK_LBRACK) {

      // Never executed if BracketAsIndirect feature is enabled.
      // [dir] or [dir],y
      NextTok();
      A->Expr = Expression();
      Consume(TOK_RBRACK, "']' expected");
      if (CurTok.Tok == TOK_COMMA) {
         // [dir],y
         NextTok();
         if (GetCPU() == CPU_45GS02) {
            Consume(TOK_Z, "'Z' expected");
            A->AddrModeSet = AM65_32BIT_BASE_IND_Z;
         }
         else {
            Consume(TOK_Y, "'Y' expected");
            A->AddrModeSet = AM65_DIR_IND_LONG_Y;
         }
      }
      else {
         // [dir]
         A->AddrModeSet = AM65_DIR_IND_LONG | AM65_ABS_IND_LONG;
      }
   }
   else {

      // Remaining stuff:
      //
      // addr
      // addr, x
      // addr, y
      // addr, s
      // addr, relative addr
      A->Expr = Expression();

      if (CurTok.Tok == TOK_COMMA) {

         NextTok();
         switch (CurTok.Tok) {

            case TOK_X:
               A->AddrModeSet = AM65_ABS_LONG_X | AM65_ABS_X | AM65_DIR_X;
               NextTok();
               break;

            case TOK_Y:
               A->AddrModeSet = AM65_ABS_Y | AM65_DIR_Y;
               NextTok();
               break;

            case TOK_S:
               A->AddrModeSet = AM65_STACK_REL;
               NextTok();
               break;

            default:
               // FIXME: syntax error if not zp, ind
               A->AddrModeSet = AM65_ZP_REL;
               break;
         }
      }
      else {

         A->AddrModeSet = AM65_ABS_LONG | AM65_ABS | AM65_DIR;
      }
   }

   // Apply addressing mode overrides
   A->AddrModeSet &= Restrictions;
}


/*
 * Copyright (c) 2018 Cesnet z.s.p.o.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the Institute nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "kadmin_locl.h"
#include "kadmin-commands.h"

int
prune(struct prune_options *opt, int argc, char **argv)
{
    krb5_error_code ret = 0;
    krb5_principal princ_ent = NULL;

    if (argc == 0) {
        krb5_warnx(context, "prune: missing principal name argument");
        return 0;
    }
    if (argc > 1) {
        krb5_warnx(context, "prune: too many arguments");
        return 0;
    }

    ret = krb5_parse_name(context, argv[0], &princ_ent);
    if (ret) {
        krb5_warn(context, ret, "krb5_parse_name %s", argv[0]);
        goto out2;
    }

    ret = kadm5_prune_principal(kadm_handle, princ_ent, opt->kvno_integer);
    if (ret)
        krb5_warn(context, ret, "kadm5_prune_principal");

out2:
    return ret != 0;
}


app)

	mp, cleanup, err := newMempoolWithApp(cc)
	require.NoError(t, err)
	defer cleanup()

	appConnCon, _ := cc()
	appConnCon.SetLogger(log.TestingLogger().With("module", "abci-client", "connection", "consensus"))
	err = appConnCon.Start()
	require.Nil(t, err)

	cacheMap := make(map[string]struct{})
	deliverTxsRange := func(start, end int) {
		// Deliver some txs.
		for i := start; i < end; i++ {

			// This will succeed
			txBytes := make([]byte, 8)
			binary.BigEndian.PutUint64(txBytes, uint64(i))
			err := mp.CheckTx(context.Background(), txBytes, nil, mempool.TxInfo{})
			_, cached := cacheMap[string(txBytes)]
			if cached {
				require.NotNil(t, err, "expected error for cached tx")
			} else {
				require.Nil(t, err, "expected no err for uncached tx")
			}
			cacheMap[string(txBytes)] = struct{}{}

			// Duplicates are cached and should return error
			err = mp.CheckTx(context.Background(), txBytes, nil, mempool.TxInfo{})
			require.NotNil(t, err, "Expected error after CheckTx on duplicated tx")
		}
	}

	reapCheck := func(exp int) {
		txs := mp.ReapMaxBytesMaxGas(-1, -1)
		require.Equal(t, len(txs), exp, fmt.Sprintf("Expected to reap %v txs but got %v", exp, len(txs)))
	}

	updateRange := func(start, end int) {
		txs := make([]types.Tx, 0)
		for i := start; i < end; i++ {
			txBytes := make([]byte, 8)
			binary.BigEndian.PutUint64(txBytes, uint64(i))
			txs = append(txs, txBytes)
		}
		if err := mp.Update(0, txs, abciResponses(len(txs), abci.CodeTypeOK), nil, nil); err != nil {
			t.Error(err)
		}
	}

	commitRange := func(start, end int) {
		ctx := context.Background()
		// Deliver some txs.
		for i := start; i < end; i++ {
			txBytes := make([]byte, 8)
			binary.BigEndian.PutUint64(txBytes, uint64(i))
			res, err := appConnCon.DeliverTxSync(ctx, abci.RequestDeliverTx{Tx: txBytes})
			if err != nil {
				t.Errorf("client error committing tx: %v", err)
			}
			if res.IsErr() {
				t.Errorf("error committing tx. Code:%v result:%X log:%v",
					res.Code, res.Data, res.Log)
			}
		}
		res, err := appConnCon.CommitSync(ctx)
		if err != nil {
			t.Errorf("client error committing: %v", err)
		}
		if len(res.Data) != 8 {
			t.Errorf("error committing. Hash:%X", res.Data)
		}
	}

	//----------------------------------------

	// Deliver some txs.
	deliverTxsRange(0, 100)

	// Reap the txs.
	reapCheck(100)

	// Reap again.  We should get the same amount
	reapCheck(100)

	// Deliver 0 to 999, we should reap 900 new txs
	// because 100 were already counted.
	deliverTxsRange(0, 1000)

	// Reap the txs.
	reapCheck(1000)

	// Reap again.  We should get the same amount
	reapCheck(1000)

	// Commit from the con


ng cart total couldn't be calculated now</returns>
		decimal? GetShoppingCartTotal(IList<OrganizedShoppingCartItem> cart,
            out decimal discountAmount, out Discount appliedDiscount,
            out List<AppliedGiftCard> appliedGiftCards,
            out int redeemedRewardPoints, out decimal redeemedRewardPointsAmount,
            bool ignoreRewardPonts = false, bool usePaymentMethodAdditionalFee = true);

        /// <summary>
        /// Gets an order discount (applied to order total)
        /// </summary>
        /// <param name="user">User</param>
        /// <param name="orderTotal">Order total</param>
        /// <param name="appliedDiscount">Applied discount</param>
        /// <returns>Order discount</returns>
        decimal GetOrderTotalDiscount(User user, decimal orderTotal, out Discount appliedDiscount);

        /// <summary>
        /// Converts reward points to amount primary store currency
        /// </summary>
        /// <param name="rewardPoints">Reward points</param>
        /// <returns>Converted value</returns>
        decimal ConvertRewardPointsToAmount(int rewardPoints);

        /// <summary>
        /// Converts an amount in primary store currency to reward points
        /// </summary>
        /// <param name="amount">Amount</param>
        /// <returns>Converted value</returns>
        int ConvertAmountToRewardPoints(decimal amount);
    }
}


 type!='view' "
      "UNION ALL "
      "SELECT type, name, sql FROM sqlite_master "
      "WHERE sql NOT NULL AND type=='view'",
      vacuumCallback1, &sVac, &zErrMsg);
  }
  if( rc==SQLITE_OK ){
    rc = sqliteBtreeCopyFile(db->aDb[0].pBt, dbNew->aDb[0].pBt);
    sqlite_exec(db, "COMMIT", 0, 0, 0);
    sqliteResetInternalSchema(db, 0);
  }

end_of_vacuum:
  if( rc && zErrMsg!=0 ){
    sqliteSetString(pzErrMsg, "unable to vacuum database - ",
       zErrMsg, (char*)0);
  }
  sqlite_exec(db, "ROLLBACK", 0, 0, 0);
  if( (dbNew && (dbNew->flags & SQLITE_Interrupt))
         || (db->flags & SQLITE_Interrupt) ){
    rc = SQLITE_INTERRUPT;
  }
  if( dbNew ) sqlite_close(dbNew);
  sqliteOsDelete(zTemp);
  sqliteFree(zTemp);
  sqliteFree(sVac.s1.z);
  sqliteFree(sVac.s2.z);
  if( zErrMsg ) sqlite_freemem(zErrMsg);
  if( rc==SQLITE_ABORT && sVac.rc!=SQLITE_INTERRUPT ) sVac.rc = SQLITE_ERROR;
  return sVac.rc;
#endif
}


m-s-inner[lang=math] {
    border-radius: var(--v-r-t) var(--v-r-t-xc) 0 0;
}
// 非 ```math 语法的公式
.md-fences .CodeMirror.cm-s-inner:not([lang=math]) {
    border-radius: var(--v-r-t) var(--v-r-t-xc);
}
// 双题注微调
.v-caption.codeblock[data-cap-count="2"] .md-fences .CodeMirror.cm-s-inner:not([lang=math]) {
    border-radius: 0;
}

// 编辑时，Mermaid 图表的代码块
@{writeOnEditing} .md-diagram .CodeMirror.cm-s-inner {
    border-radius: var(--v-r-t) var(--v-r-t-xc) 0 0;
}

.CodeMirror .CodeMirror-cursor {
    border-left: 2px solid var(--cm-CodeMirror-cursor);
}

.CodeMirror-gutters {
    border-width: 0;
    border-right: 1px solid var(--pn-c);
    height: 100% !important; // 避免代码块的题注 hover 样式的背景色透出
}

.CodeMirror-linenumber {
    color: var(--d-fc-a);
    font-family: var(--v-f-fm-num);
    min-width: fit-content !important; // 避免某些窄字体，总行数为 11 行号时，第 10 行会错位
}
// 代码块获得焦点后，突出当前行号
@{writeOnEditing} .CodeMirror-focused .CodeMirror-activeline-gutter>.CodeMirror-linenumber {
    color: var(--h-f);
    font-weight: var(--v-f-w-bd);
}

.cm-s-inner :is(.cm-variable, .cm-operator, .cm-property) {
    color: var(--cm-variable);
}

.cm-s-inner .cm-variable-2 {
    color: var(--cm-variable-2);
}

.cm-s-inner .cm-variable-3 {
    color: var(--cm-variable-3);
}

.cm-s-inner .cm-keyword {
    color: var(--cm-keyword);
}

.cm-s-inner .cm-tag {
    color: var(--cm-tag);
}

.cm-s-inner .cm-attribute {
    color: var(--cm-attribute);
}

.cm-s-inner .cm-string {
    color: var(--cm-string);
}

.cm-s-inner .cm-string-2 {
    color: var(--cm-string-2);
}

.cm-s-inner .cm-comment,
.cm-s-inner.cm-comment {
    color: var(--cm-comment);
}

.cm-s-inner :is(.cm-header, .cm-def),
.cm-s-inner.cm-header,
.cm-s-inner.cm-def {
    color: var(--cm-header);
}

.cm-s-inner .cm-quote,
.cm-s-inner.cm-quote {
    color: var(--cm-quote);
}

.cm-s-inner .cm-hr {
    color: var(--cm-hr);
}

.cm-s-inner .cm-link {
    color: var(--cm-link);
    text-decoration: none;
    border-bottom: 1px solid var(--cm-link);
}

.cm-s-inner .cm-negative {
    color: var(--cm-negative);
}

.cm-s-inner .cm-positive {
    color: var(--cm-positive);
}

.cm-s-inner :is(.cm-meta, .cm-qualifier) {


padding-left:2px;left:0}html[dir=rtl] ._3ONVk._3BI3Q{padding-right:2px;right:0}._3biCE{width:393px;max-width:464px}.TZc0i ._3ONVk{width:auto}html[dir] ._18MZW{margin:0 -3px 8px}html[dir] ._2OnBD ._18MZW{margin-top:5px}.eSSBt ._3ONVk{position:relative;top:unset;width:100%}html[dir] .eSSBt ._3ONVk{padding-top:3px}html[dir=ltr] .eSSBt ._3ONVk{left:unset;padding-left:3px}html[dir=rtl] .eSSBt ._3ONVk{right:unset;padding-right:3px}@media screen and (max-width:1100px){.iDc2T ._3ONVk{width:70%}}html[dir] ._1AETd{margin:-3px -3px 3px}._1nTo-{position:absolute;bottom:4px}html[dir=ltr] .xmUYL ._1nTo-{right:7px}html[dir=ltr] ._35VV1 ._1nTo-{right:85px}html[dir=rtl] .xmUYL ._1nTo-{left:85px}html[dir=rtl] ._35VV1 ._1nTo-{left:7px}._3QeR3{display:flex;align-items:center}.xmUYL ._3QeR3{flex-direction:row-reverse;margin-right:8px;margin-left:4px}html[dir=rtl] .xmUYL ._3QeR3{flex-direction:row}._35VV1 ._3QeR3{flex-direction:row;margin-right:4px;margin-left:8px}html[dir=rtl] ._35VV1 ._3QeR3{flex-direction:row-reverse}._35VV1 ._3QeR3._3BI3Q{margin-left:0}._9JCTX{flex-grow:1;padding-bottom:1px}.xmUYL ._9JCTX{margin-left:11px}._35VV1 ._9JCTX{margin-right:19px}.mXlJW{position:relative}._1sRhP{position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none;opacity:0;transition:opacity .2s ease-in-out}._1sRhP._23_JQ{pointer-events:auto;opacity:1}.xmUYL ._1sRhP{margin-left:2px}._35VV1 ._1sRhP{margin-left:-2px}._2xaO4{position:relative;flex:none;pointer-events:none;opacity:0;transition:opacity .2s ease-in-out}._2xaO4._3oha0{pointer-events:auto;opacity:1}._3QwUC{position:absolute;bottom:-2px}.xmUYL ._3QwUC{right:-8px}._35VV1 ._3QwUC{left:-8px}
.TwY1H{display:flex;align-items:center;direction:ltr;padding-bottom:4px}._2JShY{display:block;flex:none;width:34px;height:34px;margin-top:-1px;margin-right:12px}.h8id8,._2JShY{position:relative}.h8id8{flex:1}.R5Qhd{position:absolute;top:0;left:0}._3sMyo{position:relative;display:block;width:34px;height:34px;color:rgba(var(--icon-strong-rgb),.5)}._3sMyo._3Wjko._1m3jD{color:var(--audio-control-incoming)}._3sMyo._3Wjko._3rsWd{color:var


undo log
				tx.undoLogs = append(tx.undoLogs, tx.db.GetUndoLog(key))
			}
		}

		// 执行命令
		r := tx.db.ExecWithLock(cmdLine)

		if config.Properties.OpenAtomicTx && reply.IsErrorReply(r) {
			// 开启了原子性事务，并且如果发生错误，直接返回错误
			if !engine.IsReadOnlyCommand(cmdName) {
				// 删除错误命令的undo log，不需要增加版本号
				tx.addVersionKeys = tx.addVersionKeys[:len(tx.addVersionKeys)-1]
				tx.undoLogs = tx.undoLogs[:len(tx.undoLogs)-1]
			}

			return r
		}

		results = append(results, []byte(r.DataString()))
	}

	return reply.MakeMultiBulkStringReply(results)
}

// Cancel TCC事务的cancel阶段
func (tx *Transaction) Cancel() redis.Reply {
	tx.mu.Lock() // Cancel互斥进行操作，防止commit时调用cancel，发生冲突
	defer tx.mu.Unlock()
	defer func() {
		// 设置阶段
		tx.phase = phaseCancel
	}()

	// 从后向前依次执行undo日志，只有开启原子性事务时，len(tx.undoLogs)才可能大于0
	for i := len(tx.undoLogs) - 1; i >= 0; i-- {
		undoLog := tx.undoLogs[i]
		if len(undoLog) == 0 {
			continue
		}

		for _, cmdLine := range undoLog {
			tx.db.ExecWithLock(cmdLine)
		}

	}

	// 清空
	tx.undoLogs = nil

	return reply.MakeOkReply()
}

// End 结束分布式事务
func (tx *Transaction) End() redis.Reply {
	tx.mu.Lock()
	defer tx.mu.Unlock()

	// 检查阶段是否是commit或者cancel
	if tx.phase != phaseCommit && tx.phase != phaseCancel {
		return reply.MakeErrReply("ERR END ERROR")
	}

	defer func() {
		// 解锁
		tx.db.RWUnLocks(tx.writeKeys, tx.readKeys)
	}()

	// 取消时间轮任务
	taskKey := tx.id
	timewheel.Cancel(taskKey)

	if tx.phase == phaseCommit {
		// 若成功提交，则增加版本
		tx.db.AddVersion(tx.addVersionKeys...)
	}

	return reply.MakeOkReply()
}
package set

import "github.com/dawnzzz/simple-redis/datastruct/dict"

type SimpleSet struct {
	dict dict.Dict
}

func MakeSimpleSet(members ...string) Set {
	set := &SimpleSet{
		dict: dict.MakeSimpleDict(),
	}

	for _, member := range members {
		set.Add(member)
	}

	return set
}

func (set *SimpleSet) Add(val string) int {
	return set.dict.PutIfAbsent(val, nil)
}

func (set *SimpleSet) Remove(val string) int {
	return set.dict.Remove(val)
}

func (set *SimpleSet) Has(val string) bool {
	_, exists := set.dict.Get(val)

	return exists
}

func (set *SimpleSet) Len() int {
	return set.dict.Len()
}

func (set *SimpleSet) ToSlice() []string {
	slice := make([]string, 0, set.Len())

	set.ForEach(func(


end ov71_0222D780

	thumb_func_start ov71_0222D820
ov71_0222D820: ; 0x0222D820
	push {r4, lr}
	sub sp, #8
	add r4, r0, #0
	bl ov71_0222E558
	mov r0, #0x5d
	lsl r0, r0, #2
	ldr r0, [r4, r0]
	bl ov71_0222E578
	add r0, r4, #0
	bl ov71_0222E900
	add r0, r4, #0
	bl ov71_0222D93C
	add r0, r4, #0
	bl ov71_0222D780
	ldr r0, [r4, #8]
	ldr r0, [r0, #0x18]
	bl Options_GetFrame
	lsl r0, r0, #0x18
	lsr r0, r0, #0x18
	mov r2, #0x5d
	str r0, [sp]
	mov r0, #0x1a
	lsl r2, r2, #2
	str r0, [sp, #4]
	ldr r0, [r4, r2]
	mov r1, #0
	add r2, #0x65
	mov r3, #0xa
	bl sub_0200CD68
	mov r1, #0
	mov r2, #0x5d
	str r1, [sp]
	mov r0, #0x1a
	lsl r2, r2, #2
	str r0, [sp, #4]
	ldr r0, [r4, r2]
	add r2, #0x83
	mov r3, #0xb
	bl LoadUserFrameGfx1
	mov r3, #0x5e
	lsl r3, r3, #2
	ldr r0, [r4, r3]
	add r3, #0xc
	str r0, [sp]
	ldr r0, _0222D92C ; =0x00000588
	ldr r3, [r4, r3]
	add r0, r4, r0
	mov r1, #0xf
	mov r2, #1
	bl ov71_02230F40
	mov r0, #4
	mov r1, #1
	bl ToggleBgLayer
	mov r0, #5
	mov r1, #1
	bl ToggleBgLayer
	mov r0, #6
	mov r1, #1
	bl ToggleBgLayer
	mov r0, #0x10
	mov r1, #1
	bl GfGfx_EngineBTogglePlanes
	mov r0, #0
	mov r1, #1
	bl ToggleBgLayer
	mov r0, #1
	add r1, r0, #0
	bl ToggleBgLayer
	mov r0, #2
	mov r1, #1
	bl ToggleBgLayer
	mov r0, #3
	mov r1, #1
	bl ToggleBgLayer
	mov r0, #0x10
	mov r1, #1
	bl GfGfx_EngineATogglePlanes
	bl ov71_0222EA38
	add r0, r4, #0
	bl ov71_0222EA68
	add r0, r4, #0
	bl ov71_0222EF90
	ldr r0, _0222D930 ; =0x00002218
	mov r1, #0
	ldr r0, [r4, r0]
	add r2, r4, #0
	bl ov71_0222DBEC
	ldr r0, _0222D934 ; =0x0000221C
	mov r1, #6
	ldr r0, [r4, r0]
	add r2, r4, #0
	bl ov71_0222DBEC
	mov r0, #0xce
	lsl r0, r0, #2
	ldr r


; Generated with ikazuchi 1.0 by riidefi
; Object File: math_types
; Segments:
;     .text:       0x8000bc68 -> 0x8000bcf8

; Symbols Defined
; 8000bc68 -> 8000bcf8 VEC3TransformNormal__Q24nw4r4mathFPQ34nw4r4math4VEC3PCQ34nw4r4math5MTX34PCQ34nw4r4math4VEC3

; Exports
.global VEC3TransformNormal__Q24nw4r4mathFPQ34nw4r4math4VEC3PCQ34nw4r4math5MTX34PCQ34nw4r4math4VEC3

; Segments
.section .text
VEC3TransformNormal__Q24nw4r4mathFPQ34nw4r4math4VEC3PCQ34nw4r4math5MTX34PCQ34nw4r4math4VEC3:
.byte 0xC0, 0x64, 0x00, 0x00 # 8000bc68
.byte 0xC0, 0x45, 0x00, 0x00 # 8000bc6c
.byte 0xC0, 0x24, 0x00, 0x10 # 8000bc70
.byte 0xEC, 0xE3, 0x00, 0xB2 # 8000bc74
.byte 0xC0, 0x04, 0x00, 0x20 # 8000bc78
.byte 0xEC, 0x81, 0x00, 0xB2 # 8000bc7c
.byte 0xC0, 0x64, 0x00, 0x04 # 8000bc80
.byte 0xEC, 0x20, 0x00, 0xB2 # 8000bc84
.byte 0xC0, 0xA5, 0x00, 0x04 # 8000bc88
.byte 0xC0, 0x04, 0x00, 0x24 # 8000bc8c
.byte 0xEC, 0xC3, 0x01, 0x72 # 8000bc90
.byte 0xC0, 0x44, 0x00, 0x14 # 800


声明 值量 正在清空: (本体: 窗口_, ev: 事件_) => 任意;
//@@{ 正在结束了:onended, 窗口_:Window, 媒体流错误事件_:MediaStreamErrorEvent }
声明 值量 正在结束了: (本体: 窗口_, ev: 媒体流错误事件_) => 任意;
//@@{ 正在错误:onerror, 错误事件处理程序_:ErrorEventHandler }
声明 值量 正在错误: 错误事件处理程序_;
//@@{ 正在焦点:onfocus, 窗口_:Window, 焦点事件_:FocusEvent }
声明 值量 正在焦点: (本体: 窗口_, ev: 焦点事件_) => 任意;
//@@{ 正在哈希改变:onhashchange, 窗口_:Window, 哈希改变事件_:HashChangeEvent }
声明 值量 正在哈希改变: (本体: 窗口_, ev: 哈希改变事件_) => 任意;
//@@{ 正在输入:oninput, 窗口_:Window, 事件_:Event }
声明 值量 正在输入: (本体: 窗口_, ev: 事件_) => 任意;
//@@{ 正在无效的:oninvalid, 窗口_:Window, 事件_:Event }
声明 值量 正在无效的: (本体: 窗口_, ev: 事件_) => 任意;
//@@{ 正在键按下:onkeydown, 窗口_:Window, 键盘事件_:KeyboardEvent }
声明 值量 正在键按下: (本体: 窗口_, ev: 键盘事件_) => 任意;
//@@{ 正在键入:onkeypress, 窗口_:Window, 键盘事件_:KeyboardEvent }
声明 值量 正在键入: (本体: 窗口_, ev: 键盘事件_) => 任意;
//@@{ 正在键松开:onkeyup, 窗口_:Window, 键盘事件_:KeyboardEvent }
声明 值量 正在键松开: (本体: 窗口_, ev: 键盘事件_) => 任意;
//@@{ 正在加载:onload, 窗口_:Window, 事件_:Event }
声明 值量 正在加载: (本体: 窗口_, ev: 事件_) => 任意;
//@@{ 正在加载数据:onloadeddata, 窗口_:Window, 事件_:Event }
声明 值量 正在加载数据: (本体: 窗口_, ev: 事件_) => 任意;
//@@{ 正在加载元数据:onloadedmetadata, 窗口_:Window, 事件_:Event }
声明 值量 正在加载元数据: (本体: 窗口_, ev: 事件_) => 任意;
//@@{ 正在加载开始:onloadstart, 窗口_:Window, 事件_:Event }
声明 值量 正在加载开始: (本体: 窗口_, ev: 事件_) => 任意;
//@@{ 正在消息:onmessage, 窗口_:Window, 消息事件_:MessageEve


时整个过程中，中间不会被其他的 goroutine 打断。该函数的实现会使用内置的 JavaScript 函数 Atomics.store 来实现原子性存储操作，这个函数可以确保在执行存储操作之前和之后不会有其他线程访问存储位置。

在 Go 语言的 runtime 层面上，这个函数的主要应用场景是用来实现一些底层的并发操作，比如线程同步、锁的实现等。因为这些操作需要保证数据的原子性，否则会引发一系列问题，例如数据竞态、内存泄露，甚至程序崩溃等。因此在确保数据原子性的前提下，使用 Storeuintptr 函数可以有效地提高并发操作的效率和安全性。

### Loaduintptr

Loaduintptr函数是Go语言运行时中用于实现原子操作的函数之一。在WebAssembly平台上，它通过JavaScript的原子操作API来实现。

Loaduintptr函数的作用是读取指针指向的内存地址中的数据，并以uintptr类型的整数返回。由于WebAssembly平台上的内存地址通常是32位整数，因此返回值是uintptr类型（即无符号整数类型，占用4个字节）。

通常使用Loaduintptr函数来进行读取操作的场景是：多个线程同时读取同一个内存地址中的数据时，需要保证读取操作是原子操作，即不会出现数据竞争和数据不一致的问题。在这种情况下，可以使用Loaduintptr函数来实现读取操作的原子性。

具体实现中，Loaduintptr函数会使用JavaScript中的Atomics模块来保证读取操作的原子性。Atomics模块提供了一系列的原子操作API，这些API可以保证多个JavaScript线程之间的原子性操作。在WebAssembly平台上，Go语言运行时会使用Atomics模块来实现原子操作。

### Loaduint

在WebAssembly环境中，由于对内存的访问是限制的，因此需要使用原子操作来实现并发访问变量。atomic_wasm.go中的Loaduint函数就是这样一种原子操作。

具体来说，Loaduint函数的作用是原子地加载一个uint32类型的值，并返回它的值。它的函数签名如下：

```
func LoadUint32(addr *uint32) uint32
```

在实现中，LoadUint32函数调用了JavaScript中的Atomics.load函数来实现对内存的原子读取。它接收一个指针参数，指向要读取的uint32类型的变量，在读取时，它会原子地读取该变量的值，并返回读取的结果。

LoadUint32函数的作用非常重要，因为它能够确保变量的原子性，避免了在多线程环境中可能出现的竞态条件


 = Block.blocksList[this.getBlockId(var9, var11, var10)];

						if (var12 != null) {
							var12.addCollisionBoxesToList(this, var9, var11, var10, par2AxisAlignedBB, this.collidingBoundingBoxes, par1Entity);
						}
					}
				}
			}
		}

		double var14 = 0.25D;
		List var16 = this.getEntitiesWithinAABBExcludingEntity(par1Entity, par2AxisAlignedBB.expand(var14, var14, var14));

		for (int var15 = 0; var15 < var16.size(); ++var15) {
			AxisAlignedBB var13 = ((Entity)var16.get(var15)).getBoundingBox();

			if (var13 != null && var13.intersectsWith(par2AxisAlignedBB)) {
				this.collidingBoundingBoxes.add(var13);
			}

			var13 = par1Entity.getCollisionBox((Entity)var16.get(var15));

			if (var13 != null && var13.intersectsWith(par2AxisAlignedBB)) {
				this.collidingBoundingBoxes.add(var13);
			}
		}

		return this.collidingBoundingBoxes;
	}

	/**
	 * calculates and returns a list of colliding bounding boxes within a given AABB
	 */
	public List getCollidingBlockBounds(AxisAlignedBB par1AxisAlignedBB) {
		this.collidingBoundingBoxes.clear();
		int var2 = MathHelper.floor_double(par1AxisAlignedBB.minX);
		int var3 = MathHelper.floor_double(par1AxisAlignedBB.maxX + 1.0D);
		int var4 = MathHelper.floor_double(par1AxisAlignedBB.minY);
		int var5 = MathHelper.floor_double(par1AxisAlignedBB.maxY + 1.0D);
		int var6 = MathHelper.floor_double(par1AxisAlignedBB.minZ);
		int var7 = MathHelper.floor_double(par1AxisAlignedBB.maxZ + 1.0D);

		for (int var8 = var2; var8 < var3; ++var8) {
			for (int var9 = var6; var9 < var7; ++var9) {
				if (this.blockExists(var8, 64, var9)) {
					for (int var10 = var4 - 1; var10 < var5; ++var10) {
						Block var11 = Block.blocksList[this.getBlockId(var8, var10, var9)];

						if (var11 != null) {
							var11.addCollisionBoxesToList(this, var8, var10, var9, par1AxisAlignedBB, this.collidingBoundingBoxes, (Entity)null);
						}
					}
				}
			}
		}

		return this.collidingBoundingBoxes;
	}

	/**
	 * Returns the amount of skylight subtracted for the current time
	 */
	public int calculateSkylightSubtracted(float par1) {
		float var2 = this.getCelestialAngle(par1);
		float var3 = 1.0F - (MathHelper.cos(var2 * (float)Math.PI * 2.0F) * 2.0F + 0.5F);

		if (var3 < 0.0F) {
			var3 = 0.0F;
		}

		if (var3 > 1.0F) {
			var3 = 1.0F;
		}

		var3 = 1.0F - var3;
		var3 = (float)((double)var3 * (1.0D - (double)(this.getRainStrength(par1) * 5.0F) / 16.0D));
		var3 = (float)((double)var3 * (1.0D - (double)(this.getWeightedThunderStrength(par1) * 5.0F) / 16.0D));
		var3 = 1.0F - var3;
		return (int)(var3 * 11.0F);
	}

	/**
	 * Returns the sun brightness - checks time of day, rain and thunder
	 */
	public float getSunBrightness(float par1) {
		float var2 = this.getCelestialAngle(par1);
		float


fb >= 0; sfb--) {
							temp = s[sfb];
							int lines = s[sfb + 1] - temp;
							int i = (temp << 2) - temp + (j + 1) * lines - 1;
							while (lines > 0) {
								if (ro1[i / 18][i % 18] != 0.0f) {
									sfbcnt = sfb;
									sfb = -10;
									lines = -10;
								}
								lines--;
								i--;
							}
						}
						sfb = sfbcnt + 1;
						while (sfb < 12) {
							temp = s[sfb];
							int sb = s[sfb + 1] - temp;
							int i = (temp << 2) - temp + j * sb;
							for (; sb > 0; sb--) {
								isPos[i] = scaleFactors[1].s[j][sfb];
								if (isPos[i] != 7) {
									if (lsf) {
										iStereoKValues(isPos[i], ioType, i);
									} else {
										isRatio[i] = Constants.TAN12[isPos[i]];
									}
								}
								i++;
							} // for (; sb>0 ...
							sfb++;
						} // while (sfb<12)
						temp = s[10];
						temp2 = s[11];
						int sb = temp2 - temp;
						sfb = (temp << 2) - temp + j * sb;
						sb = s[12] - temp2;
						int i = (temp2 << 2) - temp2 + j * sb;
						for (; sb > 0; sb--) {
							isPos[i] = isPos[sfb];
							if (lsf) {
								k0[i] = k0[sfb];
								k1[i] = k1[sfb];
							} else {
								isRatio[i] = isRatio[sfb];
							}
							i++;
						}
					}
				}
			} else {
				int i = 31;
				int ss = 17;
				int sb = 0;
				while (i >= 0) {
					if (ro1[i][ss] != 0.0f) {
						sb = (i << 4) + (i << 1) + ss;
						i = -1;
					} else {
						ss--;
						if (ss < 0) {
							i--;
							ss = 17;
						}
					}
				}
				i = 0;
				while (l[i] <= sb) {
					i++;
				}
				sfb = i;
				i = l[i];
				for (; sfb < 21; sfb++) {
					sb = l[sfb + 1] - l[sfb];
					for (; sb > 0; sb--) {
						isPos[i] = scaleFactors[1].l[sfb];
						if (isPos[i] != 7) {
							if (lsf) {
								iStereoKValues(isPos[i], ioType, i);
							} else {
								isRatio[i] = Constants.TAN12[isPos[i]];
							}
						}
						i++;
					}
				}
				sfb = l[20];
				for (sb = 576 - l[21]; (sb > 0) && (i < 576); sb--) {
					isPos[i] = isPos[sfb]; // error here : i >=576
					if (lsf) {
						k0[i] = k0[sfb];
						k1[i] = k1[sfb];
					} else {
						isRatio[i] = isRatio[sfb];
					}
					i++;
				}
			}
		}
		for (int sb = 0, i = 0; sb < SBLIMIT; sb++) {
			for (int ss = 0; ss < SSLIMIT; ss++) {
				if (isPos[i] == 7) {
					if (msStereo) {
						lr0[sb][ss] = (ro0[sb][ss] + ro1[sb][ss])
								* 0.707106781


#include <u.h>
#include <libc.h>
#include <bio.h>

#define openlog auxclog_openlog	/* libc symbol on OS X */

char *argv0;

int
openlog(char *name)
{
	int fd;

	fd = open(name, OWRITE);
	if(fd < 0)
		fd = create(name, OWRITE, DMAPPEND|0666);
	if(fd < 0){
		fprint(2, "%s: can't open %s: %r\n", argv0, name);
		return -1;
	}
	seek(fd, 0, 2);
	return fd;
}

void
main(int argc, char **argv)
{
	Biobuf in;
	int fd;
	char *p, *t;
	char buf[8192];

	argv0 = argv[0];
	if(argc !=  3){
		fprint(2, "usage: %s console logfile \n", argv0);
		exits("usage");
	}

	if(strcmp(argv[1], "-") == 0)
		fd = 0;
	else
		fd = open(argv[1], OREAD);
	if(fd < 0){
		fprint(2, "%s: can't open %s: %r\n", argv0, argv[1]);
		exits("open");
	}
	Binit(&in, fd, OREAD);

	fd = openlog(argv[2]);

	for(;;){
		if(p = Brdline(&in, '\n')){
			p[Blinelen(&in)-1] = 0;
			t = ctime(time(0));
			t[19] = 0;
			if(fprint(fd, "%s: %s\n", t, p) < 0){
				close(fd);
				fd = openlog(argv[2]);
				fprint(fd, "%s: %s\n", t, p);
			}
		} else if(Blinelen(&in) == 0)	/* true eof */
			break;
		else {
			Bread(&in, buf, sizeof buf);
		}
	}
	exits(0);
}


), 0)
            flakes.add(flake)
        }
        for (f in flakes)
        {
            f.floatDown()
            if (f.rect.bottom > snowfallArea.bottom)
                flakes.remove(f)
        }
    }

    fun display(canvas: Canvas)
    {
        for (f in flakes)
            f.display(canvas)
    }
}package com.ocnyang.recyclerviewevent.concat_adapter

import android.content.Context
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ProgressBar
import androidx.paging.LoadState
import com.ocnyang.recyclerviewevent.R
import com.ocnyang.recyclerviewevent.diff_util.DiffUtilAdapter
import com.ocnyang.recyclerviewevent.diff_util.DiffUtilFruitBean
import com.ocnyang.recyclerviewevent.diff_util.DiffUtilViewHolder
import com.ocnyang.recyclerviewevent.paging3.LoadStateViewHolder
import com.ocnyang.recyclerviewevent.paging3.PagingLoadStateAdapter

class ConcatPageAdapter(context: Context, data: MutableList<DiffUtilFruitBean>) : DiffUtilAdapter(context, data)

class HeaderAdapter(context: Context, data: MutableList<DiffUtilFruitBean>) : DiffUtilAdapter(context, data) {
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): DiffUtilViewHolder {
        val itemView =
                LayoutInflater.from(context).inflate(R.layout.activity_concat_item_header, parent, false)
        return DiffUtilViewHolder(itemView)
    }
}

class FooterAdapter(context: Context) : PagingLoadStateAdapter(context) {
    override fun onBindViewHolder(holder: LoadStateViewHolder, loadState: LoadState) {
        holder.tvLoadState.text = when (loadState) {
            is LoadState.Loading -> {
                holder.progressBar.visibility = View.VISIBLE
                "正在加载"
            }
            is LoadState.Error -> {
                holder.progressBar.visibility = View.GONE
                "没有更多数据"
            }
            is LoadState.NotLoading -> {
                holder.progressBar.visibility = View.GONE
                "加载完成"
            }
        }
    }

    override fun displayLoadStateAsItem(loadState: LoadState): Boolean {
        return loadState is LoadState.NotLoading || super.displayLoadStateAsItem(loadState)
    }
}

package com.ocnyang.recyclerviewevent.diff_util

import androidx.recyclerview.widget.DiffUtil

/*******************************************************************
 *    * * * *   * * * *   *     *       @Author: OCN.Yang
 *    *     *   *         * *   *       @CreateDate: 2021/4/10 10:29 AM.
 *    *     *   *         *   * *       @Email: ocnyang@gmail.com
 *    * * * *   * * * *   *     *.Yang  @GitHub: https://github.com/OCNYang
 *******************************************************************/

class AdapterDiffCallback(
    val oldData: List<DiffUtilFruitBean>,
    val newData: List<DiffUtilFruitBean>
) : DiffUtil.Callback() {

    override fun getOldListSize(): Int = oldData.size

    override fun getNewListSize(): Int = newData.size

    /**
     * 判断两个 item 是不是同一种类型，因为 RecyclerView 支持不同的条目布局
     * 这里的 Demo 因为比较简单不涉及多类型条目，所以直接比较两种数据类型（实际这里每次返回的都是 true）
     */
    override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int) =
        oldData[oldItemPosition].javaClass == newData[newItemPosition].javaClass

    /**
     * 判


epoch: {}", epoch_str))?;

    let rank = rank_str
        .parse::<f64>()
        .with_context(|| format!("invalid rank: {}", rank_str))?;

    let path = canonicalize(&path)?;
    let path = path_to_str(&path)?;

    // If the path exists in the database, add the ranks and set the epoch to
    // the more recent of the parsed epoch and the already present epoch.
    if let Some(dir) = db.dirs.iter_mut().find(|dir| dir.path == path) {
        dir.rank += rank;
        dir.last_accessed = epoch.max(dir.last_accessed);
    } else {
        db.dirs.push(Dir {
            path: path.to_string(),
            rank,
            last_accessed: epoch,
        });
    }

    Ok(())
}
<reponame>eiz/winapi-rs-ex
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// All files in the project carrying such notice may not be copied, modified, or distributed
// except according to those terms.
//! Procedure declarations, constant definitions, and macros for the NLS component.
use ctypes::c_int;
use shared::basetsd::LONG_PTR;
use shared::guiddef::GUID;
use shared::minwindef::{
    BOOL, BYTE, DWORD, INT, LPARAM, LPDWORD, LPINT, LPVOID, LPWORD, MAX_PATH, PDWORD, PULONG, UINT,
};
use um::minwinbase::SYSTEMTIME;
use um::winnt::{
    CHAR, LANGID, LCID, LONG, LPCSTR, LPCWCH, LPCWSTR, LPSTR, LPWSTR, PCNZCH, PCNZWCH, PCWSTR,
    PCZZWSTR, PULONGLONG, PWSTR, PZZWSTR, ULONGLONG, WCHAR,
};
pub const MAX_LEADBYTES: usize = 12;
pub const MAX_DEFAULTCHAR: usize = 2;
pub const MB_PRECOMPOSED: DWORD = 0x00000001;
pub const MB_COMPOSITE: DWORD = 0x00000002;
pub const MB_USEGLYPHCHARS: DWORD = 0x00000004;
pub const MB_ERR_INVALID_CHARS: DWORD = 0x00000008;
pub const WC_COMPOSITECHECK: DWORD = 0x00000200;
pub const WC_DISCARDNS: DWORD = 0x00000010;
pub const WC_SEPCHARS: DWORD = 0x00000020;
pub const WC_DEFAULTCHAR: DWORD = 0x00000040;
pub const WC_ERR_INVALID_CHARS: DWORD = 0x00000080;
pub const WC_NO_BEST_FIT_CHARS: DWORD = 0x00000400;
pub const CP_ACP: DWORD = 0;
pub const CP_OEMCP: DWORD = 1;
pub const CP_MACCP: DWORD = 2;
pub const CP_THREAD_ACP: DWORD = 3;
pub const CP_SYMBOL: DWORD = 42;
pub const CP_UTF7: DWORD = 65000;
pub const CP_UTF8: DWORD = 65001;
pub type LGRPID = DWORD;
pub type LCTYPE = DWORD;
pub type CALTYPE = DWORD;
pub type CALID = DWORD;
STRUCT! {struct CPINFO {
    MaxCharSize: UINT,
    DefaultChar: [BYTE; MAX_DEFAULTCHAR],
    LeadByte: [BYTE; MAX_LEADBYTES],
}}
pub type LPCPINFO = *mut CPINFO;
STRUCT! {struct CPINFOEXA {
    MaxCharSize: UINT,
    DefaultChar: [BYTE; MAX_DEFAULTCHAR],
    LeadByte: [BYTE; MAX_LEADBYTES],
    UnicodeDefaultChar: WCHAR,
    CodePage: UINT,
    CodePageName: [CHAR; MAX_PATH],
}}
pub type LPCPINFOEXA = *mut CPINFOEXA;
STRUCT! {struct CPINFOEXW {
    MaxCharSize: UINT,
    DefaultChar: [BYTE; MAX_


�� - 나글바르",
	[224] = "북풍의 땅 - 나글바르",
	[225] = "호박석 절벽 - 북풍의 땅 - 콜다라로",
	[226] = "변위의 보호막 - 콜다라",
	[227] = "운송수단 시험용",
	[228] = "진화의 대지 - 애완동물 실험 시작",
	[229] = "진화의 대지 - 애완동물 실험 시작",
	[230] = "운송수단 - 투스카르 01",
	[231] = "운송수단 - 투스카르 02",
	[232] = "북풍의 땅 - 전쟁노래 요새 늑대 시작",
	[233] = "북풍의 땅 - 전쟁노래 요새 늑대 끝",
	[234] = "콜다라 절벽 - 콜다라",
	[235] = "변위의 보호막 - 콜다라",
	[236] = "콜다라 - 케리스트라자에게서 말리고스",
	[237] = "콜다라 - 케리스트라자 착륙지",
	[239] = "북풍의 땅 - 퀘스트 황혼이 시작",
	[240] = "북풍의 땅 - 퀘스트 황혼이 끝",
	[241] = "운송수단 - 용맹의 성채",
	[242] = "퀘스트 - 용의 안식처 - 영혼 환영 - 시작",
	[243] = "퀘스트 - 용의 안식처 - 영혼 환영 - 끝",
	[244] = "윈터가드 성채 - 용의 안식처",
	[245] = "용맹의 성채 - 북풍의 땅",
	[246] = "피즈크랭크 비행장 - 북풍의 땅",
	[247] = "별의 쉼터 - 용의 안식처",
	[248] = "연금술사 야영지 - 울부짖는 협만",
	[249] = "원크와 야영지 - 회색 구릉지",
	[250] = "정복의 요새 - 회색 구릉지",
	[251] = "폴드라곤 요새 - 용의 안식처",
	[2


      options.MinimumSameSitePolicy = SameSiteMode.None;
        });

        services.AddGoogleAnalyticsTracker(options =>
        {
            // ReSharper disable once StringLiteralTypo
            options.TrackerId = "UA-XXXXXX-XX";
            options.ShouldTrackRequestInMiddleware = TrackRequests.OnlyWhenNotYetTracked;
        });

        services.AddMvc();
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.UseCookiePolicy();
        app.UseRouting();

        app.UseGoogleAnalyticsTracker();

        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
        }

        app.UseStaticFiles();
        app.UseCookiePolicy();

        app.UseEndpoints(endpoints =>
        {

            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");

            endpoints.MapRazorPages();
        });
    }
}


return}else Browser.mainLoop.timingMode==0&&(Browser.mainLoop.tickStartTime=_emscripten_get_now());Browser.mainLoop.method==="timeout"&&Module.ctx&&(Module.printErr("Looks like you are rendering without using requestAnimationFrame for the main loop. You should use 0 for the frame rate in emscripten_set_main_loop in order to use requestAnimationFrame, as that can greatly improve your frame rates!"),Browser.mainLoop.method=""),Browser.mainLoop.runIter(t),!(N<Browser.mainLoop.currentlyRunningMainloop)&&(typeof SDL=="object"&&SDL.audio&&SDL.audio.queueNewAudioData&&SDL.audio.queueNewAudioData(),Browser.mainLoop.scheduler())}}},E||(l&&l>0?_emscripten_set_main_loop_timing(0,1e3/l):_emscripten_set_main_loop_timing(1,1),Browser.mainLoop.scheduler()),f)throw"SimulateInfiniteLoop"}var Browser={mainLoop:{scheduler:null,method:"",currentlyRunningMainloop:0,func:null,arg:0,timingMode:0,timingValue:0,currentFrameNumber:0,queue:[],pause:function(){Browser.mainLoop.scheduler=null,Browser.mainLoop.currentlyRunningMainloop++},resume:function(){Browser.mainLoop.currentlyRunningMainloop++;var o=Browser.mainLoop.timingMode,l=Browser.mainLoop.timingValue,f=Browser.mainLoop.func;Browser.mainLoop.func=null,_emscripten_set_main_loop(f,0,!1,Browser.mainLoop.arg,!0),_emscripten_set_main_loop_timing(o,l),Browser.mainLoop.scheduler()},updateStatus:function(){if(Module.setStatus){var o=Module.statusMessage||"Please wait...",l=Browser.mainLoop.remainingBlockers,f=Browser.mainLoop.expectedBlockers;l?l<f?Module.setStatus(o+" ("+(f-l)+"/"+f+")"):Module.setStatus(o):Module.setStatus("")}},runIter:function(o){if(!ABORT){if(Module.preMainLoop){var l=Module.preMainLoop();if(l===!1)return}try{o()}catch(f){if(f instanceof ExitStatus)return;throw f&&typeof f=="object"&&f.stack&&Module.printErr("exception thrown: "+[f,f.stack]),f}Module.postMainLoop&&Module.postMainLoop()}}},isFullscreen:!1,pointerLock:!1,moduleContextCreatedCallbacks:[],workers:[],init:function(){if(Module.preloadPlugins||(Module.preloadPlugins=[]),Browser.initted)return;Browser.initted=!0;try{new Blob,Browser.hasBlobConstructor=!0}catch{Browser.hasBlobConstructor=!1,console.log("warning: no blob constructor, cannot create blobs with mimetypes")}Browser.BlobBuilder=typeof MozBlobBuilder<"u"?MozBlobBuilder:typeof WebKitBlobBuilder<"u"?WebKitBlobBuilder:Browser.hasBlobConstructor?null:console.log("warning: no BlobBuilder"),Browser.URLObject=typeof window<"u"?window.URL?window.URL:window.webkitURL:void 0,!Module.noImageDecoding&&typeof Browser.URLObject>"u"&&(console.log("warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available."),Module.noImageDecoding=!0);var o={};o.canHandle=function(t){return!Module.noImageDecoding&&/\.(jpg|jpeg|png|bmp)$/i.test(t)},o.handle=function(t,N,F,k){var x=null;if(Browser.hasBlobConstructor)try{x=new Blob([t],{type:Browser.getMimetype(N)}),x.size!==t.length&&(x=new Blob([new Uint8Array(t).buffer],{


 alt=""><area shape="rect" coords="-332,1486,-112,1503" href="#setDoorDebounceTime(java.lang.String)" alt=""><area shape="rect" coords="-332,1503,-166,1519" href="#setDoorLabel(java.lang.String)" alt=""><area shape="rect" coords="-332,1519,-179,1536" href="#setDualCard(char)" alt=""><area shape="rect" coords="-332,1536,-171,1553" href="#setFloorPlan(java.lang.String)" alt=""><area shape="rect" coords="-332,1553,-170,1569" href="#setFromarea(java.lang.String)" alt=""><area shape="rect" coords="-332,1569,-140,1586" href="#setIgnoreExittz(java.lang.Character)" alt=""><area shape="rect" coords="-332,1586,-159,1603" href="#setInhibitAccess(char)" alt=""><area shape="rect" coords="-332,1603,-165,1619" href="#setKeypadLock(char)" alt=""><area shape="rect" coords="-332,1619,-177,1636" href="#setLocation(java.lang.String)" alt=""><area shape="rect" coords="-332,1636,-130,1653" href="#setLockReleaseSec(java.lang.String)" alt=""><area shape="rect" coords="-332,1653,-136,1670" href="#setLogAllTrans(java.lang.Character)" alt=""><area shape="rect" coords="-332,1670,-156,1686" href="#setLogicalPoint(java.lang.String)" alt=""><area shape="rect" coords="-332,1686,-171,1703" href="#setLogTrans(java.lang.String)" alt=""><area shape="rect" coords="-332,1703,-192,1720" href="#setOffset(java.lang.String)" alt=""><area shape="rect" coords="-332,1720,-160,1736" href="#setPermanentLr(char)" alt=""><area shape="rect" coords="-332,1736,-150,1753" href="#setPhysicalPoint(java.lang.String)" alt=""><area shape="rect" coords="-332,1753,-176,1770" href="#setPinLength(char)" alt=""><area shape="rect" coords="-332,1770,-184,1786" href="#setPinMode(char)" alt=""><area shape="rect" coords="-332,1786,-174,1803" href="#setPinOffset(java.lang.String)" alt=""><area shape="rect" coords="-332,1803,-188,1820" href="#setPinType(char)" alt=""><area shape="rect" coords="-332,1820,-153,1837" href="#setReaderMode(java.lang.String)" alt=""><area shape="rect" coords="-332,1837,-145,1853" href="#setResponseTag(java.lang.String)" alt=""><area shape="rect" coords="-332,1853,-175,1870" href="#setRiuMode(java.lang.String)" alt=""><area shape="rect" coords="-332,1870,-166,1887" href="#setSbarTrans(java.lang.String)" alt=""><area shape="rect" coords="-332,1887,-158,1903" href="#setShuntFactor(java.lang.String)" alt=""><area shape="rect" coords="-332,1903,-169,1920" href="#setTagName(java.lang.String)" alt=""><area shape="rect" coords="-332,1920,-185,1937" href="#setToarea(java.lang.String)" alt=""><area shape="rect" coords="-340,-375,-243,-356" href="package-summary.html" alt=""></map>
<map name="umlmap456W2H1"><area shape="rect" coords="32,-348,104,-320" href="#" alt=""><area shape="rect" coords="-812,-319,-728,-302" href="#active" alt=""><area shape="rect" coords="-812,-302,-684,-285" href="#alarmFiltertz" alt=""><area shape="rect" coords="-812,-285,-687,-269" href="#alarmTrans"


:0 20px}.mw-numlink{display:none}.mw-contributions-form fieldset{margin:20px 20px 10px}.mw-contributions-form .mw-contributions-table{margin:0 10px}#preferences{border:1px solid #ccc;margin:0}#preferences .mainLegend{display:none}#preferences fieldset.prefsection{margin:0;padding:40px}#preferences legend{border-bottom:none}#preferences fieldset+fieldset>legend{padding-top:40px}#preferences .mw-label label{white-space:nowrap;margin:0;color:#777}#preferences td{padding:5px}#preferences .htmlform-tip{color:#999;padding:1em 0 3em 12em}#preferences div.mw-prefs-buttons{margin:20px auto 0;padding:40px 40px 20px;text-align:center;overflow:hidden}#preftoc{margin:0 20px -2px 0;padding-left:0}#preftoc li,#preftoc ul{display:inline;list-style:none}#preftoc li a{position:relative;z-index:2;font:inherit;margin:0;padding:8px 15px;display:inline-block}#preftoc li.selected a{background-color:#fff;border:1px solid #ccc;border-bottom:none;border-radius:6px 6px 0 0;color:inherit;cursor:default;padding:7px 14px}.mw-prefs-buttons a{font:inherit;padding:8px 20px;float:left}.mw-prefs-buttons input{font:inherit;padding:3px 15px;float:right}#contentSub br{display:none}#mw-revision-info{border:1px solid #eee;border-bottom:none;border-radius:6px 6px 0 0;font-size:16px;padding:20px 20px .25em}#mw-revision-info,#mw-revision-nav{background:#f6f6f6;display:block;margin:0 auto;text-align:center;width:auto}#mw-revision-nav{border-radius:0 0 6px 6px;border:1px solid #eee;border-top:none;padding:0 20px 20px}#tab-pane-main-page-content #toolbar img{display:initial}#tab-pane-main-page-content a.external[href^="http://"]{background:url(/skins/solstice/public/images/external-link-ltr-icon.png) 100% no-repeat;padding-right:13px}#tab-pane-main-page-content a.external[href^="https://"],.link-https{background:url(/skins/solstice/public/images/lock-icon.png) 100% no-repeat;padding-right:13px}#tab-pane-main-page-content a.external[href^="mailto:"],.link-mailto{background:url(/skins/solstice/public/images/mail-icon.png) 100% no-repeat;padding-right:13px}#tab-pane-main-page-content a.external[href^="ftp://"],.link-ftp{background:url(/skins/solstice/public/images/file-icon.png) 100% no-repeat;padding-right:13px}#tab-pane-main-page-content a.external[href^="irc://"],#tab-pane-main-page-content a.external[href^="ircs://"],.link-irc{background:url(/skins/solstice/public/images/talk-icon.png) 100% no-repeat;padding-right:13px}#tab-pane-main-page-content a.external[href$=".mid"],#tab-pane-main-page-content a.external[href$=".MID"],#tab-pane-main-page-content a.external[href$=".midi"],#tab-pane-main-page-content a.external[href$=".MIDI"],#tab-pane-main-page-content a.external[href$=".mp3"],#tab-pane-main-page-content a.external[href$=".MP3"],#tab-pane-main-page-content a.external[href$=".ogg"],#tab-pane-main-page-content a.external[href$=".OGG"],#tab-pane-main-page-content a.external


 100,
					Math.Floor(Calculator.GetSearchingAbility_New33(fleet1, 4) * 100) / 100 + Math.Floor(Calculator.GetSearchingAbility_New33(fleet2, 4) * 100) / 100
					));

				CombinedTag.Visible = true;
			}
			else
			{
				CombinedTag.Visible = false;
			}

			if (KCDatabase.Instance.Fleet.AnchorageRepairingTimer > DateTime.MinValue)
			{
				AnchorageRepairingTimer.Text = DateTimeHelper.ToTimeElapsedString(KCDatabase.Instance.Fleet.AnchorageRepairingTimer);
				AnchorageRepairingTimer.Tag = KCDatabase.Instance.Fleet.AnchorageRepairingTimer;
				ToolTipInfo.SetToolTip(AnchorageRepairingTimer, "泊地修理タイマ\r\n開始: " + DateTimeHelper.TimeToCSVString(KCDatabase.Instance.Fleet.AnchorageRepairingTimer) + "\r\n回復: " + DateTimeHelper.TimeToCSVString(KCDatabase.Instance.Fleet.AnchorageRepairingTimer.AddMinutes(20)));
			}

			LayoutSubInformation();

			TableFleet.ResumeLayout();
		}

		void UpdateTimerTick()
		{
			for (int i = 0; i < ControlFleet.Count; i++)
			{
				ControlFleet[i].Refresh();
			}

			if (AnchorageRepairingTimer.Visible && AnchorageRepairingTimer.Tag != null)
				AnchorageRepairingTimer.Text = DateTimeHelper.ToTimeElapsedString((DateTime)AnchorageRepairingTimer.Tag);
		}

		// 空欄があれば詰める
		void LayoutSubInformation()
		{
			if (CombinedTag.Visible && !AnchorageRepairingTimer.Visible)
			{
				if (TableFleet.GetPositionFromControl(AnchorageRepairingTimer).Row != 5)
				{
					TableFleet.Controls.Remove(CombinedTag);
					TableFleet.Controls.Remove(AnchorageRepairingTimer);
					TableFleet.Controls.Add(CombinedTag, 1, 4);
					TableFleet.Controls.Add(AnchorageRepairingTimer, 1, 5);
				}
			}
			else
			{
				if (TableFleet.GetPositionFromControl(AnchorageRepairingTimer).Row != 4)
				{
					TableFleet.Controls.Remove(CombinedTag);
					TableFleet.Controls.Remove(AnchorageRepairingTimer);
					TableFleet.Controls.Add(AnchorageRepairingTimer, 1, 4);
					TableFleet.Controls.Add(CombinedTag, 1, 5);
				}
			}
		}

		private void TableFleet_CellPaint(object sender, TableLayoutCellPaintEventArgs e)
		{
			e.Graphics.DrawLine(Pens.Silver, e.CellBounds.X, e.CellBounds.Bottom - 1, e.CellBounds.Right - 1, e.CellBounds.Bottom - 1);

		}

		protected override string GetPersistString()
		{
			return "FleetOverview";
		}

	}

}


a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)",
			"a?b: c?d:e",	"(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)",
		};
		runTests(grammar, tests, "s");
	}

	/**
	 * This is a regression test for antlr/antlr4#542 "First alternative cannot
	 * be right-associative".
	 * https://github.com/antlr/antlr4/issues/542
	 */
	@Test public void testTernaryExprExplicitAssociativity() throws Exception {
		String grammar =
			"grammar T;\n" +
			"s @after {System.out.println($ctx.toStringTree(this));} : e EOF ;\n" + // must indicate EOF can follow or 'a<EOF>' won't match
			"e :<assoc=right> e '*' e" +
			"  |<assoc=right> e '+' e" +
			"  |<assoc=right> e '?' e ':' e" +
			"  |<assoc=right> e '=' e" +
			"  | ID" +
			"  ;\n" +
			"ID : 'a'..'z'+ ;\n" +
			"WS : (' '|'\\n') -> skip ;\n";
		String[] tests = {
			"a",			"(s (e a) <EOF>)",
			"a+b",			"(s (e (e a) + (e b)) <EOF>)",
			"a*b",			"(s (e (e a) * (e b)) <EOF>)",
			"a?b:c",		"(s (e (e a) ? (e b) : (e c)) <EOF>)",
			"a=b=c",		"(s (e (e a) = (e (e b) = (e c))) <EOF>)",
			"a?b+c:d",		"(s (e (e a) ? (e (e b) + (e c)) : (e d)) <EOF>)",
			"a?b=c:d",		"(s (e (e a) ? (e (e b) = (e c)) : (e d)) <EOF>)",
			"a? b?c:d : e",	"(s (e (e a) ? (e (e b) ? (e c) : (e d)) : (e e)) <EOF>)",
			"a?b: c?d:e",	"(s (e (e a) ? (e b) : (e (e c) ? (e d) : (e e))) <EOF>)",
		};
		runTests(grammar, tests, "s");
	}

	@Test public void testExpressions() throws Exception {
		String grammar =
			"grammar T;\n" +
			"s @after {System.out.println($ctx.toStringTree(this));} : e EOF ;\n" + // must indicate EOF can follow
			"e : e '.' ID\n" +
			"  | e '.' 'this'\n" +
			"  | '-' e\n" +
			"  | e '*' e\n" +
			"  | e ('+'|'-') e\n" +
			"  | INT\n" +
			"  | ID\n" +
			"  ;\n" +
			"ID : 'a'..'z'+ ;\n" +
			"INT : '0'..'9'+ ;\n" +
			"WS : (' '|'\\n') -> skip ;\n";
		String[] tests = {
			"a",		"(s (e a) <EOF>)",
			"1",		"(s (e 1) <EOF>)",
			"a-1",		"(s (e (e a) - (e 1)) <EOF>)",
			"a.b",		"(s (e (e a) . b) <EOF>)",
			"a.this",	"(s (e (e a) . this) <EOF>)",
			"-a",		"(s (e - (e a)) <EOF>)",
			"-a+b",		"(s (e (e - (e a)) + (e b)) <EOF


.Load().(uuid.UUID) {
				return nil
			}
			errCh := make(chan *roachpb.Error)
			select {
			case errorsAfterEndTxn <- errCh:
			case <-testCtx.Done():
				return nil
			}
			return <-errCh
		}
		return nil
	}))

	// Make sure that the lease gets acquired and then, upon an ambiguous
	// failure, the retry happens, and there is just one lease.
	selectErr := make(chan error)
	go func() {
		_, err := sqlDB.Exec("SELECT * FROM foo")
		selectErr <- err
	}()
	unblock := <-errorsAfterEndTxn
	unblock <- roachpb.NewError(roachpb.NewAmbiguousResultError(errors.New("boom")))
	// Make sure we see a retry, then let it succeed.
	close(<-errorsAfterEndTxn)
	// Allow anything further to proceed.
	cancel()
	// Ensure that the query completed successfully.
	require.NoError(t, <-selectErr)
}

// TestDescriptorRemovedFromCacheWhenLeaseRenewalForThisDescriptorFails makes sure that, during a lease
// periodical refresh, if the descriptor, whose lease we intend to refresh, does not exist anymore, we delete
// this descriptor from "cache" (i.e. manager.mu.descriptor).
func TestDescriptorRemovedFromCacheWhenLeaseRenewalForThisDescriptorFails(t *testing.T) {
	defer leaktest.AfterTest(t)()
	ctx := context.Background()

	// typeDescID will be set to id of the created type `typ` later.
	mu := syncutil.Mutex{}
	typeDescID := descpb.InvalidID
	typeDescName := ""
	var tdb *sqlutils.SQLRunner
	dropCompleted := make(chan bool)

	// The overall testing strategy is
	// 1. Add a testing knob immediately before the acquire a node lease inside refreshSomeLeases;
	// 2. Create a new type `typ` and acquire a lease of it;
	// 3. When the lease manager attempts to refresh the lease on `typ`, the testing knob is trigger which removes
	//    `typ` from storage;
	// 4. This allows refreshSomeLeases fail with a DescriptorNotFound error and trigger the logic that removes this
	//    descriptor entry from the lease manager's cache (namely, manager.mu.descriptor).
	// 5. Finally, we assert that the entry for `typ` is no longer in the cache.
	params := createTestServerParams()
	params.Knobs = base.TestingKnobs{
		SQLLeaseManager: &lease.ManagerTestingKnobs{
			TestingBeforeAcquireLeaseDuringRefresh: func(id descpb.ID) error {
				mu.Lock()
				defer mu.Unlock()
				if typeDescID != descpb.InvalidID && id == typeDescID {
					// Drop this type to trigger the logic that remove unfound descriptor from lease manager cache.
					tdb.Exec(t, fmt.Sprintf("DROP TYPE %v", typeDescName))
					dropCompleted <- true
				}
				return nil
			},
		},
	}

	// Set lease duration to something small so that the periodical lease refresh is kicked off often where the testing
	// knob will be invoked, and eventually the logic to remove unfound descriptor from cache will be triggered.
	lease.LeaseDuration.Override(ctx, &params.SV, time.Second)

	s, sqlDB, kvDB := serverutils.StartServer(t, params)
	defer s.Stopper().Stop(ctx)
	tdb = sqlutils.MakeSQLRunner(sqlDB)

	sql := `
					CREATE DATABASE test;
					USE test;
					CREATE TYPE typ as enum ('a', 'b');
					`
	tdb.Exec(t, sql)

	// Ensure `typ` is present in the lease manger by acquiring a lease on it.
	typeDesc := desctestutils.TestingGetTypeDescriptor(kvDB, keys.SystemSQLCodec,
		"test", "


��ԼĿҽ˶ʱгսڵһΣյĶʱ˵ɭ־ħ᳷˲Ȭ֯ڶսһսӺսʧ֡

أEx˿ͣǿͻDC17ʼ˺˺Ϊ1D6ʡɭ־ħͨǵҺ־綾ͿĨԼצӺͱǹϡѶȻʡ

ܣɭ־ħ+8ֵȡ10ʹĻܵв
ɭ־ħƤЩɫЧʹΧĻʹڶϻ+2ֵɭʱ˼ֵ+4

׵ɭ־ħ
ɭ־ħвKhorvaireܳǾסZilargoDarguunValenar,Q'barra,KarrnathBrelandɭСXen'drikҲܳAerenalϵɭ־ħһȱסľԵһЩڵĴзϢ

׵ɭ־ħ
ɭ־ħסڶ״½´ֵءChondalwoodɭ־ħΪmuskwartsΪƤ渲ŧЩŧɢµĴ̼岢۾лɭ־ħЩɭ־ħ10ʱͨDC17ǿͼĿä2D4֡ɹͨ24Сʱڲִ̼Ӱ졣ѶȻʡ

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<title>籩Ԫ</title>

<META content="text/html; charset=gb2312" http-equiv=Content-Type>
<META name=GENERATOR content="MSHTML 11.00.10586.873">
籩ԪأStorm Elemental

һƬɫıƣž͵ͳ¡¡

    ΪһƬķ籩Ԫػ籩ԪͬһչʾȻͬͻҵһ档Ǳٻ뿪סλ棬Ȼһˣ޴Ļ
    ûдڿԪλʱ籩ԪػĴѰȻıƣἫΪһƬŰױġ
    籩Ԫػ˵ٻõ籩ԪصԶ

ս
    籩ԪطǳǿҰѱΪƽصĵϴ򶷣Աʱ谭ֻҪܣǾͻͣڿУ빻Լĵ˱־롣ԪȱԶ̹

ϤEX    ͣڿеڶԷ籩Ԫؽй˺Ͷʱܵ-1ͷ

SU    籩Ԫÿֿһʱ10ӢڵĵһͷһһԻɵˣǿͼ룩DCʡ

     ߶     ǿDC  ˺
С     4Ӣ   4    12     1d4
     8Ӣ   8    14     2d4
    16Ӣ  16    18     4d4
  32Ӣ  32    24     8d4
ߵ    36Ӣ  40    26    10d4
    40Ӣ  48    28    12d4

SU</STRO


fragment.

		      URI         = scheme ":" hier-part [ "?" query ] [ "#" fragment ]

		      hier-part   = "//" authority path-abempty
		                  / path-absolute
		                  / path-rootless
		                  / path-empty
		 */

		String uriErrata1 = "\"govway.org\""; // manca lo scheme
		String jsonErrateUri1 = "{ \"email\": ["+emailCorrette+"], \"uuid\": ["+uuidCorretti+"], \"uri\":["+uriErrata1+"], \"hostname\":["+hostnameCorretti+"], \"ipv4\":["+ipCorretti+"], \"ipv6\":["+ip6Corretti+"] }";
		tipoTest.add("ERROR-URI-1");
		messagggioTest.add(jsonErrateUri1);
		erroreAttesoTest.add(true);
		msgErroreAttesoTest_request_openapi4j.add("body.uri.0: Value 'govway.org' does not match format 'uri'. (code: 1007)");
		msgErroreAttesoTest_response_openapi4j.add("body.uri.0: Value 'govway.org' does not match format 'uri'. (code: 1007)");
		msgErroreAttesoTest_request_swagger_request.add("SKIP");
		msgErroreAttesoTest_response_swagger_request.add("SKIP");
		msgErroreAttesoTest_request_json_schema.add("1009 $.uri[0]: does not match the uri pattern");
		msgErroreAttesoTest_response_json_schema.add("1009 $.uri[0]: does not match the uri pattern");

		// Nessuna libreria lo rileva
//		String uriErrata2 = "\"http:\""; // manca lo hier part
//		String jsonErrateUri2 = "{ \"email\": ["+emailCorrette+"], \"uuid\": ["+uuidCorretti+"], \"uri\":["+uriErrata2+"], \"hostname\":["+hostnameCorretti+"], \"ipv4\":["+ipCorretti+"], \"ipv6\":["+ip6Corretti+"] }";
//		tipoTest.add("ERROR-URI-2");
//		messagggioTest.add(jsonErrateUri2);
//		erroreAttesoTest.add(true);

		// *** Test5: hostname errata ***

		String hostnameErrata1 = "\"test_con_underscore\"";
		String jsonErrateHostname1 = "{ \"email\": ["+emailCorrette+"], \"uuid\": ["+uuidCorretti+"], \"uri\":["+uriCorrette+"], \"hostname\":["+hostnameErrata1+"], \"ipv4\":["+ipCorretti+"], \"ipv6\":["+ip6Corretti+"] }";
		tipoTest.add("ERROR-HOSTNAME-1");
		messagggioTest.add(jsonErrateHostname1);
		erroreAttesoTest.add(true);
		msgErroreAttesoTest_request_openapi4j.add("body.hostname.0: Value 'test_con_underscore' does not match format 'hostname'. (code: 1007)");
		msgErroreAttesoTest_response_openapi4j.add("body.hostname.0: Value 'test_con_underscore' does not match format 'hostname'. (code: 1007)");
		msgErroreAttesoTest_request_swagger_request.add("SKIP");
		msgErroreAttesoTest_response_swagger_request.add("SKIP");
		msgErroreAttesoTest_request_json_schema.add("1009 $.hostname[0]: does not match the hostname patter


++) {
    const property = node.properties[i]
    if (property.type as any === 'SpreadElement') {
      state.opCodes.push({ op: OP.LOADK }) // key placeholder for spread element
      compile((property as any).argument, state)
      propKinds.push('sprd')
    } else {
      // key
      const propKey = property.key
      if (property.computed) {
        compile(propKey, state)
      } else {
        state.opCodes.push({ op: OP.LOADK, val: (propKey as estree.Identifier).name })
      }
      // value
      compile(property.value, state)
      propKinds.push(property.kind)
    }
  }
  state.opCodes.push({ op: OP.OBJ, val: propKinds })
}

export function FunctionExpression(node: estree.FunctionExpression, state: State) {
  if (node.id && node.id.name) {
    state.symbols.pushScope()
    // allocate a placeholder for a tmp function to use inside the function scope
    const pointer = state.symbols.set(node.id.name, 'const').pointer
    state.opCodes.push({ op: OP.LOADK })
    state.opCodes.push({ op: OP.STORE, val: pointer , alloc: true })
    // compile the function
    compileFunc(node, state)
    // store the function into the placeholder above
    state.opCodes.push({ op: OP.COPY })
    state.opCodes.push({ op: OP.STORE, val: pointer })
    state.symbols.popScope()
  } else {
    compileFunc(node, state)
  }
}

export function UnaryExpression(node: estree.UnaryExpression, state: State) {
  if (node.operator === 'delete') {
    if (node.argument.type === 'MemberExpression') {
      compile(node.argument.object, state)
      const property = node.argument.property
      if (node.argument.computed) {
        compile(property, state)
      } else {
        state.opCodes.push({ op: OP.LOADK, val: (property as estree.Identifier).name })
      }
    } else if (node.argument.type === 'Identifier') {
      throw new SyntaxError('Delete of an unqualified identifier')
    } else {
      state.opCodes.push({ op: OP.LOADK, val: {} })
      state.opCodes.push({ op: OP.LOADK, val: '#sval_fake_delete#' })
    }
  } else if (node.operator === 'typeof' && node.argument.type === 'Identifier') {
    try {
      state.opCodes.push({ op: OP.LOADV, val: state.symbols.get(node.argument.name).pointer })
    } catch (err) {
      state.opCodes.push({ op: OP.LOADK })
    }
  } else {
    compile(node.argument, state)
  }
  state.opCodes.push({ op: OP.UNOP, val: node.operator })
}

export function UpdateExpression(node: estree.UpdateExpression, state: State) {
  if (node.argument.type === 'Identifier') {
    // load value
    const pointer = state.symbols.get(node.argument.name).pointer
    state.opCodes.push({ op: OP.LOADV, val: pointer })
    // update value
    if (!node.prefix) {
      state.opCodes.push({ op: OP.COPY })
    }
    state.opCodes.push({ op: OP.LOADK, val: 1 })
    state.opCodes.push({ op: OP.BIOP, val: node.operator[0] })
    if (node.prefix) {
      state.opCodes.push({ op: OP.COPY })
    }
    // store value
    state.opCodes.push({ op: OP.STORE, val: pointer })
  } else if (node.argument.ty


: #fff;
}

/*
 * colors variables
 */
.qa-title {
  padding: 15px 25px 15px 20px;
  margin-bottom: 10px;
  background-color: #fff;
}

.qa-title .title h2 {
  margin-bottom: 10px;
}

.qa-title .title .tag {
  padding: 1px 7px;
  background: #e1ecf4;
  color: #0077cc;
}

.qa-title .title .author {
  font-weight: bold;
  color: #0077cc;
}

.qa-title .share {
  height: 60px;
}

.qa-title .share .share-go {
  padding-top: 15px;
  list-style: none;
}

.qa-title .share .share-go li {
  display: inline-block;
  cursor: pointer;
}

.qa-title .share .share-go li img {
  width: 20px;
  height: 20px;
}

/*
 * colors variables
 */
.problem-detail {
  padding: 18px;
  background-color: #fff;
}

.problem-detail .sidebar {
  float: left;
  width: 32px;
  background-color: #E8E8E8;
  color: #000;
  font-size: 16px;
  position: relative;
}

.problem-detail .sidebar .tooltip-inner {
  width: 150px;
  font-size: 12px;
}

.problem-detail .sidebar button {
  width: 32px;
  border: 0;
  background-color: transparent;
}

.problem-detail .sidebar .count {
  display: block;
  line-height: 30px;
  text-align: center;
}

.problem-detail .title {
  margin-left: 50px;
  padding-bottom: 15px;
}

.problem-detail .title p {
  line-height: 26px;
  font-size: 14px;
}

.problem-detail .title pre {
  margin: 10px 0;
  line-height: 1.45;
  max-height: 35em;
  overflow: auto;
}

.problem-detail .operate {
  margin-top: 15px;
  overflow: hidden;
}

.problem-detail .operate span {
  margin-right: 15px;
  cursor: pointer;
  color: #9a9a9a;
}

.problem-detail .operate img {
  width: 22px;
  height: 22px;
  border-radius: 15px;
}

.problem-detail .answer-intro {
  overflow: hidden;
  margin-top: 15px;
  padding-bottom: 15px;
  border-bottom: 1px solid #ccc;
}

.problem-detail .answer-intro .answer-num {
  margin-bottom: 15px;
  line-height: 36px;
  border-bottom: 1px solid #ccc;
}

.problem-detail .comment-box {
  display: none;
  margin-top: 8px;
  padding: 11px 17px;
  background: #F3F3F3;
}

.problem-detail .comment-box .comment-form textarea {
  width: 80%;
  font-size: 14px;
  height: 25px;
  padding-left: 10px;
  line-height: 25px;
  border-color: #D1D1D1;
  border-radius: 5px;
}

.problem-detail .comment-box .comment-form .submit-comment {
  padding: 6px 15px;
  font-size: 14px;
  font-family: "微软雅黑";
  background-color: #FFF;
}

.problem-detail .comment-box .tips {


BA */  lui     $at, %hi(D_80BA6FD0)       ## $at = 80BA0000
/* 00134 80BA61A4 C4246FD0 */  lwc1    $f4, %lo(D_80BA6FD0)($at)
/* 00138 80BA61A8 10000003 */  beq     $zero, $zero, .L80BA61B8
/* 0013C 80BA61AC E6040054 */  swc1    $f4, 0x0054($s0)           ## 00000054
.L80BA61B0:
/* 00140 80BA61B0 C4266FD4 */  lwc1    $f6, %lo(D_80BA6FD4)($at)
/* 00144 80BA61B4 E6060054 */  swc1    $f6, 0x0054($s0)           ## 00000054
.L80BA61B8:
/* 00148 80BA61B8 E6080174 */  swc1    $f8, 0x0174($s0)           ## 00000174
/* 0014C 80BA61BC 8FBF002C */  lw      $ra, 0x002C($sp)
/* 00150 80BA61C0 8FB00028 */  lw      $s0, 0x0028($sp)
/* 00154 80BA61C4 27BD0040 */  addiu   $sp, $sp, 0x0040           ## $sp = 00000000
/* 00158 80BA61C8 03E00008 */  jr      $ra
/* 0015C 80BA61CC 00000000 */  nop


                   inline fun toString(format: String): String = format.format(this)"""
            }
        }
    }
}
package uns.format

//import kotlinx.datetime.*
import uns.BigInt
import uns.bigInt

internal class Sprintf(val format: String, val args: Array<out Any?>) {

    private var pos = 0
    private var specStart = -1
    private val result = StringBuilder()
    private var currentIndex = 0

    fun process(): Sprintf {
        while (pos < format.length) {
            val ch = format[pos++]
//            println("$ch $pos $specStart [$result]")
            if (ch == '%')
                specStart = when {
                    specStart == pos - 1 -> {
                        result.append(ch)
                        -1
                    }
                    specStart < 0 -> pos
                    else -> invalidFormat("unexpected %")
                }
            else
                if (specStart >= 0) {
                    pos--
                    Specification(this, currentIndex++).scan()
                } else result.append(ch)
        }
        return this
    }

    internal fun nextChar(): Char {
        if (pos >= format.length) invalidFormat("unexpected end of string inside format specification")
        return format[pos++]
    }

    internal fun invalidFormat(reason: String): Nothing = throw IllegalArgumentException("bad format: $reason at ofset ${pos - 1} of \"$format\"")

    override fun toString(): String = result.toString()

    internal fun isNumber(index: Int): Boolean = args[index] is Number
    internal fun getNumber(index: Int): Number = notNullArg(index)
    internal fun getBigInt(index: Int): BigInt = when (val arg = args[index]!!) {
        is BigInt -> arg
        is UByte -> arg.bigInt
        is UShort -> arg.bigInt
        is UInt -> arg.bigInt
        is ULong -> arg.bigInt
        else -> error("")
    }

    internal fun getText(index: Int): String = args[index]!!.toString()

    internal fun getCharacter(index: Int): Char = notNullArg(index)

    internal fun specificationDone(text: String) {
        result.append(text)
        specStart = -1
    }

//    fun getLocalDateTime(index: Int): LocalDateTime = when (val t = notNullArg<Any>(index)) {
//        is Instant -> t.toLocalDateTime(TimeZone.currentSystemDefault())
//        is LocalDateTime -> t
//        is LocalDate -> t.atTime(0, 0, 0)
//        else -> ConvertToInstant(t).toLocalDateTime(TimeZone.currentSystemDefault())"
//    }

    @Suppress("UNCHECKED_CAST")
    fun <T> notNullArg(index: Int): T = args[index]!! as T

    fun pushbackArgumentIndex() {
        currentIndex--
    }
}

/**
 * Old good C-sprintf. See formats table in the
 * [readme](https://github.com/sergeych/mp_stools/blob/263cfc50f23cfde815928c7bdb748857fdaad2b0/README.md#L56-L56)
 */
fun String.sprintf(vararg args: Any?): String = Sprintf(this, args).process().toString()

/**
 * Old good C-printf. See formats table in readme. Just like C version it does not insert \n. See also
 * [sprintf]
 */
fun printf(format: String, vararg args: Any?) {
    print(Sprintf(format, args).process().toString())
}

/**
 * Like old good C printf but also adds new line (via println). See [sprintf]
 */
@Suppress("unused")
fun printlnf(format: String, vararg args: Any?) {
    println(Sprintf(format, args).process().toString())
}

fun String.format(vararg args: Any?): String = Sprintf(this, args).process().toString()

//expect fun ConvertToInstant(t: Any): Instant@file:Suppress("unused")

package it.basic

import RootPackageClass

/**
 * This class, unlike [RootPackageClass] is located in a sub-package
 */
class PublicClass {
    /**
     * This function is public and documented
     */
    fun publicDocumentedFunction(): String = ""

    fun publicUndocumentedFunction(): String = ""

    /**
     * This


Handle a signal return; Pending signals should be in r18.  */
	/* Not all registers are saved by the normal trap/interrupt entry
	   points (for instance, call-saved registers (because the normal
	   C-compiler calling sequence in the kernel makes sure they're
	   preserved), and call-clobbered registers in the case of
	   traps), but signal handlers may want to examine or change the
	   complete register state.  Here we save anything not saved by
	   the normal entry sequence, so that it may be safely restored
	   (in a possibly modified form) after do_signal returns.  */

	la	r5, r1, PTO;		/* Arg 1: struct pt_regs *regs */
	add	r6, r0, r0;		/* Arg 2: sigset_t *oldset */
	addi  r7, r0, 0;	/* Arg 3: int in_syscall */
	bralid	r15, do_signal;	/* Handle any signals */
	nop;

/* Finally, return to user state.  */
1:	swi	r0, r0, PER_CPU(KM);	/* Now officially in user state. */
	add	r11, r0, CURRENT_TASK; /* Get current task ptr into r11 */
	swi	r11, r0, PER_CPU(CURRENT_SAVE); /* save current */
	VM_OFF;
	tophys(r1,r1);

	lwi	r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
	lwi	r4, r1, PTO+PT_R4;
	RESTORE_REGS
	addik	r1, r1, STATE_SAVE_SIZE		/* Clean up stack space.  */

	lwi	r1, r1, PT_R1 - PT_SIZE;
					/* Restore user stack pointer. */
	bri	6f;

/* Return to kernel state.  */
2:	VM_OFF;
	tophys(r1,r1);
	lwi	r3, r1, PTO+PT_R3; /* restore saved r3, r4 registers */
	lwi	r4, r1, PTO+PT_R4;
	RESTORE_REGS
	addik	r1, r1, STATE_SAVE_SIZE		/* Clean up stack space.  */

	tovirt(r1,r1);
6:
DBTRAP_return:		/* Make global symbol for debugging */
	rtbd	r14, 0;	/* Instructions to return from an IRQ */
	nop;

ENTRY(_switch_to)
	/* prepare return value */
	addk	r3, r0, r31

	/* save registers in cpu_context */
	/* use r11 and r12, volatile registers, as temp register */
	/* give start of cpu_context for previous process */
	addik	r11, r5, TI_CPU_CONTEXT
	swi	r1, r11, CC_R1
	swi	r2, r11, CC_R2
	/* skip volatile registers.
	 * they are saved on stack when we jumped to _switch_to() */
	/* dedicated registers */
	swi	r13, r11, CC_R13
	swi	r14, r11, CC_R14
	swi	r15, r11, CC_R15
	swi	r16, r11, CC_R16
	swi	r17, r11, CC_R17
	swi	r18, r11, CC_R18
	/* save non-volatile registers */
	swi	r19, r11, CC_R19
	sw


          options
        } else {
            val returnList: List<String>
            try {
                // Sorting the list can cause the game to crash... so let's try to handle the situation
                returnList = options.filter {it.startsWith(args[0], ignoreCase = true)}
                return returnList
            } catch (ex: java.lang.Exception) {
                ex.printStackTrace()
            }
            return listOf()
        }
    }
}

class ElnCablePaceCommand: IConsoleCommand {
    override val name = "cablePace"

    override fun runCommand(ics: ICommandSender, args: List<String>) {
        cprint(ics, "The cable pace is set to ${Eln.cablePowerFactor}")
    }

    override fun getManPage(ics: ICommandSender, args: List<String>) {
        cprint(ics, "Simply prints the Cable Pace on the server.", indent = 1)
        cprint(ics, "")
        cprint(ics, "No input parameters.", indent = 1)
        cprint(ics, "")
    }
}

class ElnLampAgingCommand: IConsoleCommand {
    override val name = "lampAging"

    override fun runCommand(ics: ICommandSender, args: List<String>) {
        if (args.size == 1) {
            val lampAging = getArgBool(ics, args[0])?: return
            SaveConfig.instance?.electricalLampAging = lampAging
            cprint(ics, "Lamp aging: ${FC.DARK_GREEN}${boolToStr(lampAging)}", indent = 1)
            cprint(ics, "Parameter saved in the map.", indent = 1)
        } else {
            cprint(ics, "This command only takes one argument - true or false")
        }
    }

    override fun getManPage(ics: ICommandSender, args: List<String>) {
        cprint(ics, "Enables/disables aging on lamps.", indent = 1)
        cprint(ics, "Changes stored into the map.", indent = 1)
        cprint(ics, "")
        cprint(ics, "Parameters :", indent = 1)
        cprint(ics, "@0:bool : Lamp aging (enabled/disabled).", indent = 2)
        cprint(ics, "")
    }

    override fun requiredPermission() = listOf(UserPermission.IS_OPERATOR)

    override fun getTabCompletion(args: List<String>): List<String> {
        val options = listOf("true", "false")
        return if (args.isEmpty() || args[0] == "") {
            options
        } else {
            return options.filter {it.startsWith(args[0], ignoreCase = true)}
        }
    }
}

class ElnBatteryAgingCommand: IConsoleCommand {
    override val name = "batteryAging"

    override fun runCommand(ics: ICommandSender, args: List<String>) {
        if (args.size == 1) {
            val lampAging = getArgBool(ics, args[0])?: return
            SaveConfig.instance?.batteryAging = lampAging
            cprint(ics, "Non portable batteries aging: ${FC.DARK_GREEN}${boolToStr(lampAging)}", indent = 1)
            cprint(ics, "Parameter saved in the map.", indent = 1)
        } else {
            cprint(ics, "This command only takes one argument - true or false")
        }
    }

    override fun getManPage(ics: ICommandSender, args: List<String>) {
        cprint(ics, "Enables/disables aging on standard batteries.", indent = 1)
        cprint(ics, "Changes stored into the map.", indent = 1)
        cprint(ics, "")
        cprint(ics, "Parameters:", indent = 1)
        cprint(ics, "@0:bool : Battery aging (enabled/disabled).", indent = 2)
        cprint(ics, "")
    }

    override fun requiredPermission() = listOf(UserPermission


= "LFT",
			pages = {
				"GPS",
			},
			id = "PageNameGPS",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameGPSBIT1 = {
		{
			alignment = "LFT",
			pages = {
				"GPSBIT1",
			},
			id = "PageNameGPSBIT1",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameGPSBIT2 = {
		{
			alignment = "LFT",
			pages = {
				"GPSBIT2",
			},
			id = "PageNameGPSBIT2",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameGPSBIT3 = {
		{
			alignment = "LFT",
			pages = {
				"GPSBIT3",
			},
			id = "PageNameGPSBIT3",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameGPSBIT4 = {
		{
			alignment = "LFT",
			pages = {
				"GPSBIT4",
			},
			id = "PageNameGPSBIT4",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameGPSBIT5 = {
		{
			alignment = "LFT",
			pages = {
				"GPSBIT5",
			},
			id = "PageNameGPSBIT5",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameGPSKEYS = {
		{
			alignment = "LFT",
			pages = {
				"GPSKEYS",
			},
			id = "PageNameGPSKEYS",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameGPSSTAT1 = {
		{
			alignment = "LFT",
			pages = {
				"GPSSTAT1",
			},
			id = "PageNameGPSSTAT1",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameHARS = {
		{
			alignment = "LFT",
			pages = {
				"HARS",
			},
			id = "PageNameHARS",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameINS = {
		{
			alignment = "LFT",
			pages = {
				"INS",
			},
			id = "PageNameINS",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameINSSTAT = {
		{
			alignment = "LFT",
			pages = {
				"INSSTAT",
			},
			id = "PageNameINSSTAT",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameLASTE = {
		{
			alignment = "LFT",
			pages = {
				"LASTE",
			},
			id = "PageNameLASTE",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameLRUTEST = {
		{
			alignment = "LFT",
			pages = {
				"LRUTEST",
			},
			id = "PageNameLRUTEST",
			index = 0,
			static_text = true,
			x = 2,
			y = 1,
		},
	},
	PageNameMXLOG = {
		{
			alignm