वार आदमी | नर चिह्न | पुरुष ',
        hasSkinTone: true),
    Emoji('🚴♀',
        'खेल | बाइक | साइकलिस्ट | साइकिल | साइकिल चलाता व्यक्ति | साइकिल सवार औरत | मादा चिह्न ',
        hasSkinTone: true),
    Emoji('🚵♂',
        'खेल | पहाड़ | पहाड़ पर साइकिल | पहाड़ पर साइकिल चलाता व्यक्ति | पहाड़ी | बाइक | साइकलिस्ट | साइकिल आदमी | नर चिह्न | पुरुष ',
        hasSkinTone: true),
    Emoji('🚵♀',
        'खेल | पहाड़ | पहाड़ पर साइकिल | पहाड़ पर साइकिल चलाता व्यक्ति | पहाड़ी | बाइक | साइकलिस्ट | साइकिल औरत | मादा चिह्न ',
        hasSkinTone: true),
    Emoji('🤸♂',
        'एक्टिव | कलाबाज़ी | कलाबाज़ी करता व्यक्ति | कलाबाज़ी करती महिला | खुश | खेल | गाड़ी का पहिया | जिमनास्टिक्स | फ़्लिप | व्यक्ति आदमी | नर चिह्न | पुरुष ',
        hasSkinTone: true),
    Emoji('🤸♀',
        'एक्टिव | कलाबाज़ी | कलाबाज़ी करता व्यक्ति | कलाबाज़ी करती महिला | खुश | खेल | गाड़ी का पहिया | जिमनास्टिक्स | फ़्लिप | व्यक्ति औरत | मादा चिह्न ',
        hasSkinTone: true),
    Emoji('🤼♂',
        'कुश्ती | खिलाड़ी | झगड़ा | पहलवान | पुरुष खिलाड़ी | रेसलिंग | लोग आदमी | नर चिह्न | पुरुष ',
        hasSkinTone: true),
    Emoji('🤼♀',
        'कुश्ती | खिलाड़ी | झगड़ा | पहलवान | पुरुष खिलाड़ी | रेसलिंग | लोग औरत | मादा चिह्न ',


xt> ent : versionedObjUniqueIndexDelete.entrySet()) {
							IndexBulkDeleteSql.addValueForDeleteByOidVersion(ent.getValue(), state.tenantId, state.eh, ent.getKey().indexType, oid, null);
							if (ent.getValue().getCurrentSize() >= state.rdb.getBatchSize()) {
								ent.getValue().execute();
							}
						}
					}
				}

				for (Map.Entry<IndexTableKey, BulkDeleteContext> ent : versionedObjUniqueIndexDelete.entrySet()) {
					if (ent.getValue().getCurrentSize() > 0) {
						ent.getValue().execute();
					}
				}

				versionedUniqueInexedOids.clear();
			}
		}
	}

	public void close() {
		if (objStoreDelete != null) {
			try {
				objStoreDelete.close();
			} catch (SQLException e) {
				logger.error("fail to BulkDeleteHandler close. maybe resource leak.", e);
			}
		}
		if (objRefDeleteByOid != null) {
			try {
				objRefDeleteByOid.close();
			} catch (SQLException e) {
				logger.error("fail to BulkDeleteHandler close. maybe resource leak.", e);
			}
		}
		if (objIndexDelete != null) {
			for (Map.Entry<IndexTableKey, BulkDeleteContext> ent: objIndexDelete.entrySet()) {
				try {
					ent.getValue().close();
				} catch (SQLException e) {
					logger.error("fail to BulkDeleteHandler close. maybe resource leak.", e);
				}
			}
		}
		if (versionedObjUniqueIndexDelete != null) {
			for (Map.Entry<IndexTableKey, BulkDeleteContext> ent : versionedObjUniqueIndexDelete.entrySet()) {
				try {
					ent.getValue().close();
				} catch (SQLException e) {
					logger.error("fail to BulkDeleteHandler close. maybe resource leak.", e);
				}
			}
		}
	}

}
/*
 * Copyright (C) 2015 DENTSU SOKEN INC. All Rights Reserved.
 *
 * Unless you have purchased a commercial license,
 * the following license terms apply:
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */

package org.iplass.mtp.impl.datastore.grdb.strategy.metadata.diff;

import java.sql.SQLException;
import java.sql.Statement;

import org.iplass.mtp.impl.entity.property.MetaProperty;
import org.iplass.mtp.impl.rdb.adapter.RdbAdapter;

public class DelProperty extends Diff {

	private MetaProperty deletedProperty;

	public DelProperty(MetaProperty deletedProperty) {
		this.deletedProperty = deletedProperty;
	}

	@Override
	public void applyToData(Statement stmt, RdbAdapter rdb, int tenantId) throws SQLException {
		//MetaDataから削除時にはデータは消さない。（不用意な削除からデータ復旧できるように。）
	}

	@Override
	public void modifyMetaData() {
	}

	@Override
	public


utStr = _mat3.str(mat3A);
outVal = _mat3.frob(mat3A);
outMat3 = _mat3.add(outMat3, mat3A, mat3B);
outMat3 = _mat3.subtract(outMat3, mat3A, mat3B);
outMat3 = _mat3.sub(outMat3, mat3A, mat3B);
outMat3 = _mat3.multiplyScalar (outMat3, mat3A, 2);
outMat3 = _mat3.multiplyScalarAndAdd (outMat3, mat3A, mat3B, 2);
outBool = _mat3.exactEquals(mat3A, mat3B);
outBool = _mat3.equals(mat3A, mat3B);

//_mat4
outMat4 = _mat4.create();
outMat4 = _mat4.clone(mat4A);
outMat4 = _mat4.copy(outMat4, mat4A);
outMat4 = _mat4.fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
outMat4 = _mat4.set(outMat4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
outMat4 = _mat4.identity(outMat4);
outMat4 = _mat4.transpose(outMat4, mat4A);
outMat4Null = _mat4.invert(outMat4, mat4A);
outMat4 = _mat4.adjoint(outMat4, mat4A);
outVal = _mat4.determinant(mat4A);
outMat4 = _mat4.multiply(outMat4, mat4A, mat4B);
outMat4 = _mat4.mul(outMat4, mat4A, mat4B);
outMat4 = _mat4.translate(outMat4, mat4A, vec3A);
outMat4 = _mat4.scale(outMat4, mat4A, vec3A);
outMat4Null = _mat4.rotate(outMat4, mat4A, Math.PI, vec3A);
outMat4 = _mat4.rotateX(outMat4, mat4A, Math.PI);
outMat4 = _mat4.rotateY(outMat4, mat4A, Math.PI);
outMat4 = _mat4.rotateZ(outMat4, mat4A, Math.PI);
outMat4 = _mat4.fromTranslation(outMat4, vec3A);
outMat4Null = _mat4.fromRotation(outMat4, Math.PI, vec3A);
outMat4 = _mat4.fromScaling(outMat4, vec3A);
outMat4 = _mat4.fromXRotation(outMat4, Math.PI);
outMat4 = _mat4.fromYRotation(outMat4, Math.PI);
outMat4 = _mat4.fromZRotation(outMat4, Math.PI);
outMat4 = _mat4.fromRotationTranslation(outMat4, quatA, vec3A);
outVec3 = _mat4.getTranslation(outVec3, mat4A);
outVec3 = _mat4.getScaling(outVec3, mat4A);
outQuat = _mat4.getRotation(outQuat, mat4A);
outMat4 = _mat4.fromRotationTranslationScale(outMat4, quatA, vec3A, vec3B);
outMat4 = _mat4.fromRotationTranslationScaleOrigin(outMat4, quatA, vec3A, vec3B, vec3A);
outMat4 = _mat4.fromQuat(outMat4, quatB);
outMat4 = _mat4.frustum(outMat4, -1, 1, -1, 1, -1, 1);
outMat4 = _mat4.perspective(outMat4, Math.PI, 1


  position: relative;
  text-align: left;
}
.td_block_template_7 .td-block-title:before {
  content: '';
  position: absolute;
  width: 100%;
  height: 100%;
  top: 0;
  left: 0;
  background: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAIAQMAAAALP6d4AAAABlBMVEUAAABmZmZ+SwYRAAAAAnRSTlMAOF6RdaYAAAAVSURBVAjXY1BgcGBoAEIHIEuAQQAAEdAB4b4poC8AAAAASUVORK5CYII=') repeat top left;
}
.td_block_template_7 .td-block-title > * {
  background-color: #fff;
  color: #000;
  padding: 0 5px;
  margin-left: 10px;
  margin-right: 10px;
  line-height: 21px;
  position: relative;
}
.td_block_template_7 .td-subcat-filter {
  line-height: 45px;
  margin-top: -1px;
}
.td_block_template_7 .td-subcat-filter .td-subcat-dropdown {
  line-height: 1;
  position: static;
}
.td_block_template_7 .td-subcat-dropdown .td-subcat-more {
  padding-left: 0;
  margin-bottom: 0 !important;
}
.td_block_template_7 .td-subcat-list .td-subcat-item {
  margin-left: 0 !important;
  margin-right: 24px;
}
.td_block_template_7 .td-subcat-list .td-subcat-item:last-child {
  margin-right: 16px;
}
.td_block_template_7 .td-related-title .td-cur-simple-item {
  color: #4db2ec;
}
@-moz-document url-prefix() {
  .td_block_template_7 .td-subcat-filter {
    margin-top: -2px;
  }
}
.td_block_template_8 .td-block-title {
  font-size: 20px;
  font-weight: 800;
  margin-top: 0;
  margin-bottom: 18px;
  line-height: 29px;
  position: relative;
  overflow: hidden;
  text-align: left;
}
.td_block_template_8 .td-block-title > * {
  position: relative;
  padding-right: 20px;
  color: #000;
}
.td_block_template_8 .td-block-title > *:before,
.td_block_template_8 .td-block-title > *:after {
  content: '';
  display: block;
  height: 4px;
  position: absolute;
  top: 50%;
  margin-top: -2px;
  width: 2000px;
  background-color: #f5f5f5;
}
.td_block_template_8 .td-block-title > *:before {
  left: 100%;
}
.td_block_template_8 .td-block-title > *:after {
  right: 100%;
}
.td_block_template_8 .td-related-title a {
  /* responsive portrait phone */
}
@media (max-width: 767px) {
  .td_block_template_8 .td-related-title a {
    font-size: 15px;
  }
}
.td_block_template_8 .td-related-title a:before {
  display: none;
}
.td_block_template_8 .td-related-title a:first-child:after {
  display: none;
}
.td_block_template_8 .td-related-title a:last-child:after {
  left: 100%;
  right: auto;
}
.td_block_template_8 .td-related-title .td-cur-simple-item {


      let header = req.header();
        for field in header.fields() {
            carrier.insert(field.name(), field.value());
        }

        let context = track_try_unwrap!(SpanContext::extract_from_http_header(&carrier));
        let tracer = self.tracer.lock().expect("Cannot acquire lock");
        let _span = tracer
            .span("Hello::handle_request")
            .child_of(&context)
            .start();
        let body = format!("Hello: {}\n", req.url().path());
        Box::new(ok(Res::new(Status::Ok, body)))
    }
}

fn main() -> trackable::result::MainResult {
    let (tracer, span_rx) = Tracer::new(AllSampler);
    let handler = Hello {
        tracer: Arc::new(Mutex::new(tracer)),
    };
    std::thread::spawn(move || {
        let reporter = track_try_unwrap!(JaegerCompactReporter::new("http_hello_server"));
        for span in span_rx {
            track_try_unwrap!(reporter.report(&[span]));
        }
    });

    let mut builder = ServerBuilder::new(track_any_err!("127.0.0.1:8081".parse())?);
    track!(builder.add_handler(handler))?;
    let server = builder.finish(fibers_global::handle());
    track!(fibers_global::execute(server))?;
    Ok(())
}
use crate::*;
use accelerometer::vector::I16x3;
use embassy_traits::spi::FullDuplex;
use embedded_hal::digital::v2::OutputPin;

pub use accelerometer::{vector::F32x3, Accelerometer};

pub enum ClickSource {
    Single,
    Double,
}

pub enum ClickInterupt {
    None,
    Int1(InterruptConfig),
    Int2(InterruptConfig),
}

impl Default for ClickInterupt {
    fn default() -> Self {
        ClickInterupt::Int1(InterruptConfig::default())
    }
}

// See INT_DUR register on lis2dw12 spec
pub struct ClickTimeInOdrCycles {
    // the time it takes to for the thing to stop moving below its threshold (20ms) (e.g 20ms => 0.02 * 200hz = 4)
    pub limit: u8,

    // the minimum time between taps - a typical double click is 100ms-200ms long (e.g 100ms => 0.1 * 200hz = 20)
    pub latency: u8,

    // cant repeat a double click until at least 500ms has passed (also the maximum time between taps) (e.g 500ms => 0.5 * 200hz = 100)
    pub window: u8,
}

fn to_u8_non_zero(val: f64) -> u8 {
    let x = val as u8;
    if x == 0 {
        1
    } else {
        x
    }
}

impl ClickTimeInOdrCycles {
    pub fn new(odr: OutputDataRate) -> Self {
        let factor = match odr {
            OutputDataRate::PowerDown => 0.0,
            OutputDataRate::Hz1 => 1.0,
            OutputDataRate::Hz10 => 10.0,
            OutputDataRate::Hz25 => 25.0,
            OutputDataRate::Hz50 => 50.0,
            OutputDataRate::Hz100 => 100.0,
            OutputDataRate::Hz200 => 200.0,
            OutputDataRate::Hz400 => 400.0,
            OutputDataRate::HighRate0 => 1620.0,
            OutputDataRate::HighRate1 => 1344.0,
        };

        // the time it takes to for the thing to stop moving below its threshold (20ms)
        let limit = to_u8_non_zero(0.02 * factor);

        // the minimum time between taps - a typical double click is 100ms-200ms long (100ms)
        let latency = to_u8_non_zero(0.1 * factor);

        // cant repeat a double click until at least 500ms has passed (also the maximum time between taps)
        let window = to_u8_non_zero(0.5 * factor) -


lture
      ..template = LocalDate(2011, 5, 3),
    Data.ymd(2011, 1, 3)
      ..pattern = 'MMMM dddd'
      ..text = 'FullNonGenName Monday'
      ..culture = TestCultures.GenitiveNameTestCulture
      ..template = LocalDate(2011, 5, 3),
    Data.ymd(2011, 1, 3)
      ..pattern = 'MMM'
      ..text = 'AbbrNonGenName'
      ..culture = TestCultures.GenitiveNameTestCulture
      ..template = LocalDate(2011, 5, 3),
    Data.ymd(2011, 1, 3)
      ..pattern = 'MMM ddd'
      ..text = 'AbbrNonGenName Mon'
      ..culture = TestCultures.GenitiveNameTestCulture
      ..template = LocalDate(2011, 5, 3),
    // Genitive month name when the pattern includes 'day of month'
    Data.ymd(2011, 1, 3)
      ..pattern = 'MMMM dd'
      ..text = 'FullGenName 03'
      ..culture = TestCultures.GenitiveNameTestCulture
      ..template = LocalDate(2011, 5, 3),
    // TODO: Check whether or not this is actually appropriate
    Data.ymd(2011, 1, 3)
      ..pattern = 'MMM dd'
      ..text = 'AbbrGenName 03'
      ..culture = TestCultures.GenitiveNameTestCulture
      ..template = LocalDate(2011, 5, 3),

    // Era handling
    Data.ymd(2011, 1, 3)
      ..pattern = 'yyyy MM dd gg'
      ..text = '2011 01 03 A.D.',
    Data.ymd(2011, 1, 3)
      ..pattern = 'uuuu yyyy MM dd gg'
      ..text = '2011 2011 01 03 A.D.',
    Data.ymd(-1, 1, 3)
      ..pattern = 'yyyy MM dd gg'
      ..text = '0002 01 03 B.C.',

    // Day of week handling
    Data.ymd(2011, 10, 9)
      ..pattern = 'yyyy MM dd dddd'
      ..text = '2011 10 09 Sunday',
    Data.ymd(2011, 10, 9)
      ..pattern = 'yyyy MM dd ddd'
      ..text = '2011 10 09 Sun',

    // Month handling
    Data.ymd(2011, 10, 9)
      ..pattern = 'yyyy MMMM dd'
      ..text = '2011 October 09',
    Data.ymd(2011, 10, 9)
      ..pattern = 'yyyy MMM dd'
      ..text = '2011 Oct 09',

    // Year and two-digit year-of-era in the same format. Note that the year
    // gives the full year information, so we're not stuck in the 20th/21st century
    Data.ymd(1825, 10, 9)
      ..pattern = 'uuuu yy MM/dd'
      ..text = '1825 25 10/09',

    // Negative years
    Data.ymd(-43, 3, 15)
      ..pattern = 'uuuu MM dd'
      ..text = '-0043 03 15',

    // Calendar handling
    Data.ymd(2011, 10, 9)
      ..pattern = 'c yyyy MM dd'
      ..text = 'ISO 2011 10 09',
    Data.ymd(2011, 10, 9)
      ..pattern = 'yyyy MM dd c'
      ..text = '2011 10 09 ISO',
    /* todo: @SkipMe.unimplemented()
    new Data.ymdc(2011, 10, 9, CalendarSystem.Coptic)
      ..Pattern = 'c uuuu MM dd'
      ..Text = 'Coptic 2011 10 09',
    new Data.ymdc(2011, 10, 9, CalendarSystem.Coptic)
      ..Pattern = 'uuuu MM dd c'
      ..Text = '2011 10 09 Coptic',

    new Data.ymdc(180, 15, 19, CalendarSystem.Badi)
      ..Pattern = 'uuuu MM dd c'
      ..Text = '01


IHNhYm9y 61911
IGNoYW5nZW1lbnQ= 61912
ZGhh 61913
IGNvbWXDp291 61914
IGdhdGVz 61915
IEFzc2lzdGFuY2U= 61916
IHJhemxpxI0= 61917
2YjYrNiv 61918
TGFuZ3VhZ2Vz 61919
IGxhbmRlbg== 61920
ZWhpY2xlcw== 61921
IOCwieCwguCwnw== 61922
bWVhbA== 61923
INC/0LDRhw== 61924
IGd1bHA= 61925
IFNjaG5l 61926
SGFi 61927
INix24HYpw== 61928
4KS14KS+4KSy 61929
IGtvbGw= 61930
4YOQ4YOn 61931
5oiR55qE 61932
5Lqk5piT 61933
IGpvdGth 61934
4KuL4Kqu4Kq+4KqC 61935
IHBvdXJ0YW50 61936
dmFpcw== 61937
b21vcw== 61938
YW1tYXQ= 61939
15nXqdeo15DXnA== 61940
IHNwb2tlc21hbg== 61941
KHRlbXBsYXRl 61942
dW1tYWE= 61943
5Li0 61944
15zXkQ== 61945
IG9sdQ== 61946
0LjRj9C4 61947
IGluY2lk 61948
QW1vbmc= 61949
4K6e 61950
X3JlZA== 61951
IEJyZXhpdA== 61952
IGVwaQ== 61953
YWluaQ== 61954
IEt5bGU= 61955
aG9l 61956
IGhpbGFyaW91cw== 61957
2YbYr9mI 61958
IGJ1bHVu 61959
YWRpYw== 61960
ZW5o 61961
IEZsaXA= 61962
IE3DvG5jaGVu 61963
IFNleG8= 61964
X2NoYW5nZWQ= 61965
IGNocmlzdGlhbg== 61966
0KDQsNC3 61967
Z29y 61968
INCx0L7RjtC90YfQsA== 61969
U1RSVUNU 61970
X2NvdW50cw== 61971
IG3Dumx0 61972
IEluag== 61973
IENoYXJ0ZXI= 61974
IHRoxrDhu51uZw== 61975
bWF5YQ== 61976
b3JyaWRv 61977
Z2V0dG8= 61978
IGtvbnN0cg== 61979
Lmxhbmd1YWdl 61980
IGJsb2Vk 61981
IGp1bmhv 61982
IEV4Y2VsbGVuY2U= 61983
IFNlcmc= 61984
4oCM2KrZiNin2YY= 61985
RXhlcmNpc2U= 61986
IElkYWhv 61987
IGNhbGxiYWNrcw== 61988
CWF0 61989
IGN5bQ== 61990
LmFuaW0= 61991
77u/Cg== 61992
IGNoYXR0aW5n 61993
IGFsZW0= 61994
2KfYudin2Ko= 61995
ZGVwYXJ0 61996
INiq2YjZh9in2YY= 61997
dXJpYQ== 61998
5Yia 61999
IGRow6lhbmFtaA== 62000
4KS+4KSa4KS+4KSw 62001
fWNhdGNo 62002
IGNoZWZz 62003
LlNoYXJlZA== 62004
Y3BsdXNwbHVz 62005
INC60LDQutC40LU= 62006
IHRlbHM


    case "M-1":
            context.person_with_m_to_one_relation = PersonWithMToOneRelation.from_json(
                context.json_string
            )

@then('"Person" has a method address which returns "{type}"')
def step_impl(context, type):
    address = getattr(context.person, "address")
    return_type = str(signature(address.fget).return_annotation)
    # clean up the return annotation to only show the return type
    return_type = re.sub(
        "(typing\.)|(aissemble_test_data_delivery_pyspark_model\.record\.address\.)|(class)|(<)|(>)|(')|(\s)",
        "",
        str(return_type),
    )
    nt.assert_true(return_type == type)

@then("the record relations are maintained as JSON string")
def step_impl(context):
    expected_json_string = context.relation_json_map.get(context.multiplicity)

    nt.assert_equal(
        expected_json_string,
        context.json_string,
        msg="Serialized JSON string did not match the expected JSON string",
    )

@then("the record relations are maintained as a Record object")
def step_impl(context):
    match context.multiplicity:
        case "1-1":
            assert_address(
                context.address, context.person_with_one_to_one_relation.address
            )
        case "M-1":
            assert_address(
                context.address, context.person_with_m_to_one_relation.address
            )
            nt.assert_equal(
                "Test Field",
                context.person_with_m_to_one_relation.custom_field,
                msg="Deserialized JSON string did not have the expected Custom Field",
            )
        case "1-M":
            for deserialized_address in context.person_with_one_to_m_relation.address:
                assert_address(context.address, deserialized_address)

def assert_address(expected_address, actual_address):
    nt.assert_equal(
        expected_address.street,
        actual_address.street,
        msg="Deserialized JSON string did not have the expected Street",
    )
    nt.assert_equal(
        expected_address.city,
        actual_address.city,
        msg="Deserialized JSON string did not have the expected City",
    )
    nt.assert_equal(
        expected_address.state.value,
        actual_address.state.value,
        msg="Deserialized JSON string did not have the expected State",
    )
    nt.assert_equal(
        expected_address.zipcode.value,
        actual_address.zipcode.value,
        msg="Deserialized JSON string did not have the expected Zipcode",
    )


# file descriptor for STDOUT
.equ STDOUT, 1

# file descriptor for STDIN
.equ STDIN, 0

# success exit code
.equ SUCCESS, 0

# single byte in memory
CHAR:
    .byte 0

.text

.global _start

_start:
    # read(STDIN, CHAR, 1)
    mov rax, SYS_READ
    mov rdi, STDIN
    mov rsi, offset CHAR
    mov rdx, 1
    syscall

    # write(STDOUT, CHAR, 1)
    mov rax, SYS_WRITE
    mov rdi, STDOUT
    mov rsi, offset CHAR
    mov rdx, 1
    syscall

    # exit(SUCCESS)
    mov rax, SYS_EXIT
    mov rdi, SUCCESS
    syscall


-> Self {
        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
    }
}

#[cfg(any(feature = "v3_14", feature = "dox"))]
impl SetValue for CompressionType {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
#[non_exhaustive]
pub enum GutterRendererAlignmentMode {
    Cell,
    First,
    Last,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for GutterRendererAlignmentMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "GutterRendererAlignmentMode::{}",
            match *self {
                GutterRendererAlignmentMode::Cell => "Cell",
                GutterRendererAlignmentMode::First => "First",
                GutterRendererAlignmentMode::Last => "Last",
                _ => "Unknown",
            }
        )
    }
}

#[doc(hidden)]
impl ToGlib for GutterRendererAlignmentMode {
    type GlibType = gtk_source_sys::GtkSourceGutterRendererAlignmentMode;

    fn to_glib(&self) -> gtk_source_sys::GtkSourceGutterRendererAlignmentMode {
        match *self {
            GutterRendererAlignmentMode::Cell => {
                gtk_source_sys::GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL
            }
            GutterRendererAlignmentMode::First => {
                gtk_source_sys::GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST
            }
            GutterRendererAlignmentMode::Last => {
                gtk_source_sys::GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST
            }
            GutterRendererAlignmentMode::__Unknown(value) => value,
        }
    }
}

#[doc(hidden)]
impl FromGlib<gtk_source_sys::GtkSourceGutterRendererAlignmentMode>
    for GutterRendererAlignmentMode
{
    fn from_glib(value: gtk_source_sys::GtkSourceGutterRendererAlignmentMode) -> Self {
        skip_assert_initialized!();
        match value {
            0 => GutterRendererAlignmentMode::Cell,
            1 => GutterRendererAlignmentMode::First,
            2 => GutterRendererAlignmentMode::Last,
            value => GutterRendererAlignmentMode::__Unknown(value),
        }
    }
}

impl StaticType for GutterRendererAlignmentMode {
    fn static_type() -> Type {
        unsafe { from_glib(gtk_source_sys::gtk_source_gutter_renderer_alignment_mode_get_type()) }
    }
}

impl<'a> FromValueOptional<'a> for GutterRendererAlignmentMode {
    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
        Some(FromValue::from_value(value))
    }
}

impl<'a> FromValue<'a> for GutterRendererAlignmentMode {
    unsafe fn from_value(value: &Value) -> Self {
        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
    }
}

impl SetValue for GutterRendererAlignmentMode {
    unsafe fn set_value(value: &mut Value, this: &Self) {
        gobject_sys::g_value_set_enum(value.to_glib_none_


xpd O9g5cc uUPGi">

Stack Overflow › questions › scrapi...

Scraping and parsing Google search results using Python - Stack ...

Oct 12, 2011 · 7 answers

I asked a question on realizing a general idea to crawl and save webpages.
Part of the original question is: how to crawl and save a lot of "About" pages ...

<g-scrolling-carousel class="NyXVTe" data-restore="" data-ss="" id="_Cz9kX7bME8-e5gKO8JGgBw15" jsaction="OaAmdd:EDKYjb;JnGzAc:aJ8u7;qVN0Rc:nnsrCf;EormBc:HFYvKc;gEKQDb:yUtVib;keydown:uYT2Vb;rcuQ6b:npT2md" jscontroller="XjCeUc" jsdata="JcTXNb;;AC1IZA" jsname="kVgvCc" jsshadow=""><div class="mR2gOd" data-hveid="CAUQBw" data-ved="2ahUKEwj2_emX9vHrAhVPj1kKHQ54BHQQjtkCMAt6BAgFEAc"


) == Position(33784, 32205, 14) then
		local status = player:getStorageValue(Storage.Quest.U11_50.DangerousDepths.Dwarves.Points)
		if (hasWarzoneAccess() and status >= 10) or (not hasWarzoneAccess() and status >= 15) then
			player:teleportTo(Position(33921, 32401, 14))
		else
			player:sendTextMessage(MESSAGE_EVENT_ADVANCE, "You can not use this portal yet.")
			player:teleportTo(Position(fromPosition.x - 1, fromPosition.y, fromPosition.z))
		end
	elseif player:getPosition() == Position(33921, 32402, 14) then
		player:teleportTo(Position(33782, 32205, 14))
	elseif player:getPosition() == Position(33829, 32187, 14) then
		local status = player:getStorageValue(Storage.Quest.U11_50.DangerousDepths.Gnomes.Points)
		if (hasWarzoneAccess() and status >= 10) or (not hasWarzoneAccess() and status >= 15) then
			player:teleportTo(Position(33982, 32236, 14))
		else
			player:sendTextMessage(MESSAGE_EVENT_ADVANCE, "You can not use this portal yet.")
			player:teleportTo(Position(fromPosition.x, fromPosition.y - 1, fromPosition.z))
		end
	elseif player:getPosition() == Position(33982, 32234, 14) then
		player:teleportTo(Position(33829, 32186, 14))
	end

	player:getPosition():sendMagicEffect(CONST_ME_TELEPORT)

	return true
end

for index, value in pairs(positions) do
	energyEntrance:position(value)
end

energyEntrance:register()


est`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List addPeerRequestDescriptor = $convert.base64Decode(
    'Cg5BZGRQZWVyUmVxdWVzdBIeCgRwZWVyGAEgASgLMgoucm9vbS5QZWVyUgRwZWVy');
@$core.Deprecated('Use addPeerReplyDescriptor instead')
const AddPeerReply$json = const {
  '1': 'AddPeerReply',
  '2': const [
    const {'1': 'success', '3': 1, '4': 1, '5': 8, '10': 'success'},
    const {
      '1': 'error',
      '3': 2,
      '4': 1,
      '5': 11,
      '6': '.room.Error',
      '10': 'error'
    },
  ],
};

/// Descriptor for `AddPeerReply`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List addPeerReplyDescriptor = $convert.base64Decode(
    'CgxBZGRQZWVyUmVwbHkSGAoHc3VjY2VzcxgBIAEoCFIHc3VjY2VzcxIhCgVlcnJvchgCIAEoCzILLnJvb20uRXJyb3JSBWVycm9y');
@$core.Deprecated('Use getPeersRequestDescriptor instead')
const GetPeersRequest$json = const {
  '1': 'GetPeersRequest',
  '2': const [
    const {'1': 'sid', '3': 1, '4': 1, '5': 9, '10': 'sid'},
  ],
};

/// Descriptor for `GetPeersRequest`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List getPeersRequestDescriptor =
    $convert.base64Decode('Cg9HZXRQZWVyc1JlcXVlc3QSEAoDc2lkGAEgASgJUgNzaWQ=');
@$core.Deprecated('Use getPeersReplyDescriptor instead')
const GetPeersReply$json = const {
  '1': 'GetPeersReply',
  '2': const [
    const {'1': 'success', '3': 1, '4': 1, '5': 8, '10': 'success'},
    const {
      '1': 'error',
      '3': 2,
      '4': 1,
      '5': 11,
      '6': '.room.Error',
      '10': 'error'
    },
    const {
      '1': 'Peers',
      '3': 3,
      '4': 3,
      '5': 11,
      '6': '.room.Peer',
      '10': 'peers'
    },
  ],
};

/// Descriptor for `GetPeersReply`. Decode as a `google.protobuf.DescriptorProto`.
final $typed_data.Uint8List getPeersReplyDescriptor = $convert.base64Decode(
    'Cg1HZXRQZWVyc1JlcGx5EhgKB3N1Y2Nlc3MYASABKAhSB3N1Y2Nlc3MSIQoFZXJyb3IYAiABKAsyCy5yb29tLkVycm9yUgVlcnJvchIgCgVQZWVycxgDIAMoCzIKLnJvb20uUGVlclIFcGVlcnM=');
@$core.Deprecated('Use messageDescriptor instead')
const Message$json = const {
  '1': 'Message',
  '2': const [
    const {'1': 'from', '3': 1, '4': 1, '5': 9, '10': 'from'},
    const {'1': 'to', '3': 2, '4': 1, '5': 9, '10': 'to


您的应用程序的 CPU 使用率。这使得开发人员能够在应用程序需求很大的时候，自动将新的服务器添加到负载平衡器。自动扩展提供了一个真正的不干预方法，同时还能确保及时满足用户的需求。当您由于某些原因需要计划外地使用您的应用程序时，自动扩展非常重要，比如让您的移动应用程序短时间内出现在应用商店里，而您的后端服务却驻留在云中。

### 您应该选择哪种应用程序扩展？

作为开发人员，您应该选择一个允许您的应用程序 **同时** 进行手动扩展和自动水平扩展的平台。

## 应用程序状态

大多数云提供商提供了一个 PaaS，希望您开始进行全新开发，也就是说，这些项目不受之前工作的约束的影响。将现有或遗留应用程序移植到该平台可能是一个挑战，主要因为文件系统实际上是短暂的，不允许将应用程序状态或资源保存在文件系统上。这个限制就是您可能听说考虑让将来的应用程序成为无状态应用程序的原因。要从驻留在云中的基础架构中获得好处，您需要在您的项目中使用无状态应用程序设计。为达到这一目的，请考虑对新的应用程序采用以下实践：

- 允许应用程序服务器或容器跨集群维护用户的会话状态，而不是依赖于文件系统。
- 不要在您的代码所部署到的服务器的物理文件系统上存储文件或用户资产。相反，可以考虑使用一个基于云的存储服务，通过为了存储服务而提供的 REST API 来交付资产。
- 使用一个数据库来存储与用户相关的资产（如果您无法使用云存储 API）。

### 您应该选择哪种应用程序状态？

对于全新应用程序，您应该设计无状态的应用程序，这意味着它们不会在文件系统上存储用户资产或资源。对于遗留或现有应用程序，可以选择一个既支持有状态应用程序又支持无状态应用程序的 PaaS 提供商。

## 针对支持云的应用程序的数据库

几乎目前创建的所有应用程序都依赖于后端上某种类型的数据库，用该数据库来存储和检索将要呈现给用户的信息。在针对云开发应用程序时，还必须考虑您将要使用哪些数据库，以及这些数据库应该位于何处。数据库应该与应用程序位于同一台服务器上，还是应该位于单


0 z1 z2 z3]_d
// ymm8  <- dirty
// ymm9  <- dirty
// ymm10 <- dirty
// ymm11 <- dirty
// ymm15 <- dirty
//
// output arguments:
// ymm0 <- [z0 z1 z2 z3]
// ymm1 <- dirty
// ymm2 <- dirty
// ymm3 <- dirty
// ymm8  <- dirty
// ymm9  <- dirty
// ymm10 <- dirty
// ymm11 <- dirty
// ymm15 <- dirty

#if MACRO_LEVEL>=1
	.macro INNER_BLEND_N_4_LIB4
#else
	.p2align 4,,15
	FUN_START(inner_blend_n_4_lib4)
#endif

	// reduction
	vaddpd	%ymm0, %ymm1, %ymm0
	vaddpd	%ymm2, %ymm3, %ymm2
	vaddpd	%ymm0, %ymm2, %ymm0

#if MACRO_LEVEL>=1
	.endm
#else
	ret

	FUN_END(inner_blend_n_4_lib4)
#endif

// common inner routine with file scope
//
// blend for ta==t
//
// input arguments:
// ymm0 <- [z0a z0b z0c z0d]
// ymm1 <- [z1a z1b z1c z1d]
// ymm2 <- [z2a z2b z2c z2d]
// ymm3 <- [z3a z3b z3c z3d]
// ymm8  <- dirty
// ymm9  <- dirty
// ymm10 <- dirty
// ymm11 <- dirty
// ymm15 <- dirty
//
// output arguments:
// ymm0 <- [z0 z1 z2 z3]
// ymm1 <- dirty
// ymm2 <- dirty
// ymm3 <- dirty
// ymm8  <- dirty
// ymm9  <- dirty
// ymm10 <- dirty
// ymm11 <- dirty
// ymm15 <- dirty

#if MACRO_LEVEL>=1
	.macro INNER_BLEND_T_4_LIB4
#else
	.p2align 4,,15
	FUN_START(inner_blend_t_4_lib4)
#endif

	// reduction
	vhaddpd	%ymm1, %ymm0, %ymm0
	vhaddpd	%ymm3, %ymm2, %ymm2
	vperm2f128	$ 0x2, %ymm0, %ymm2, %ymm1
	vperm2f128	$ 0x13, %ymm0, %ymm2, %ymm0
	vaddpd	%ymm0, %ymm1, %ymm0

#if MACRO_LEVEL>=1
	.endm
#else
	ret

	FUN_END(inner_blend_t_4_lib4)
#endif

// common inner routine with file scope
//
// blend for ta==t, scale for generic alpha and beta
//
// input arguments:
// r10  <- alpha
// r11  <- beta
// r12  <- y
// ymm0 <- [z0 z1 z2 z3]
//
// output arguments:
// r10  <- alpha
// r11  <- beta
// r12  <- y
// ymm0 <- [z0 z1 z2 z3]

#if MACRO_LEVEL>=1
	.macro INNER_SCALE_AB_4_LIB4
#else
	.p2align 4,,15
	FUN_START(inner_scale_ab_4_lib4)
#endif

	// alpha
	vbroadcastsd	0(%r10), %ymm15
	vmulpd	%ymm0, %ymm15, %ymm0

	// beta
	vbroadcastsd	0(%r11), %ymm15

	vxorpd		%ymm14, %ymm14, %ymm14 // 0.0
	vucomisd	%xmm14,


FF_OR_CAR = 'staffOrCar',
  ANY = 'any'
}

export enum PayMethod {
  APP = 'jetaid',
  CASH = 'cash',
  ANY = 'any'
}

export enum SmokePolicy {
  NO_SMOKE = 'nosmoke',
  ALLOW_SMOKE = 'allowsmoke',
  FLEX = 'flex'
}

export enum PetPolicy {
  NO_PET = 'nopet',
  ALLOW_PET = 'allowpet',
  FLEX = 'flex'
}

export enum CurbPolicy {
  CURB_ONLY = 'curbonly',
  ALLOW_PARKING = 'allowparking',
  ALLOW_UNDERGROUND = 'allowunderground',
  FLEX = 'flex'
}

/** For use in html: Enum --> pretty display */
export function displayRideToward(value: RideToward){
  if(!value) return '???';
  switch (value) {
    case RideToward.AIRPORT:
      return 'To';
    case RideToward.CITY:
      return 'From';
    default:
      return '???'
  }
}

export enum UsageType {
  SEAT = 'seat',
  LUGGAGE = 'luggage',
  BABY_SEAT = 'baby_seat',
  SPORT_EQUIP = 'sport_equip'
}

/** Group logic of RidePrefs and RideType together
 * + RidePrefs.CAB_ONLY is mapped to:
 * ++ rider.pref = CAB_ONLY
 * ++ ride.type = SHARE_CAB
 * + RidePrefs.STAFF_OR_CAR is mapped to:
 * ++ rider.pref = STAFF_OR_CAR
 * ++ ride.type = null
 * + RidePrefs.ANY is mapped to:
 * ++ rider.pref = ANY
 * ++ ride.type = SHARE_CAB
 * + RidePrefs.CAB_OR_CAR:
 * ++ rider.pref = ANY
 * ++ ride.type = OWN_CAR*/
export enum RiderChoice {
  SHARE_CAB = 'shareCab',
  JOIN_CARPOOL = 'joinCarPool',
  JOIN_CAB_OR_CARPOOL = 'joinCarOrCarPool',
  OFFER_RIDE = 'offerRide'
}

export const USAGE_OPTIONS: {[key: string]: ChoiceCardOption} = {
  'luggage': {
    title: 'Luggage',
    subTitle: 'Large piece of luggage you are bringing',
    value: 'luggage',
    link: null,
    iconRef: 'ICON_LUGGAGE'
  },
  'seat': {
    title: 'Seat',
    subTitle: 'Seat you\'ll need for this ride',
    value: 'seat',
    link: null,
    iconRef: 'ICON_SEAT'
  }
}

export const RIDER_OPTIONS = <ChoiceCardOption[]> [
  {
    title: 'Join a Ride',
    subTitle: 'Open to either sharing a taxi ride or a carpool',
    value: RiderChoice.JOIN_CAB_OR_CARPOOL,
    iconRef: 'ICON_JOIN'
  },
  {
    title: 'Offer a Ride',
    subTitle: 'Let others ride in your car.',
    value: RiderChoice.OFFER_RIDE,
    iconRef: 'ICON_CAR'
  },
  {
    title: 'Share a Taxi Only',
    subTitle: 'Split the fare with another rider',
    value: RiderChoice.SHARE_CAB,
    iconRef: 'ICON_TAXI'
  },
  {
    title: 'Join a Carpool',
    subTitle: 'Ride in someone else\'s car',
    value: RiderChoice.JOIN_CARPOOL,
    iconRef: 'ICON_TASK'
  },

];

/** Group logic of RidePrefs and RideType together
 * + SHARE_CAB is mapped to CAB_ONLY
 * + JOIN_CARPOOL is mapped to STAFF_OR_CAR
 * + ANY is mapped to ANY
 * + OFFER_RIDE is mapped to STAFF_OR_CAR*/
export const riderChoiceToPref = (choice: RiderChoice): RidePrefs => {
  if(!cho


UC_HOOK_MEM_WRITE_PROT, hook_mem_invalid, NULL, 1, 0);

    // emulate machine code in infinite time
    printf("BEGIN execution - 1\n");
    err = uc_emu_start(uc, 0x400000, 0x400000 + sizeof(PROGRAM), 0, 10);
    if (err) {
        printf("Expected failue on uc_emu_start() with error returned %u: %s\n",
                err, uc_strerror(err));
    } else {
        printf("UNEXPECTED uc_emu_start returned UC_ERR_OK\n");
    }
    printf("END execution - 1\n");

    // emulate machine code in infinite time
    printf("BEGIN execution - 2\n");
    //update eax to point to aligned memory (same as add eax,7 above)
    uint32_t eax = 0x40002C;
    uc_reg_write(uc, UC_X86_REG_EAX, &eax);
    //resume execution at the mov dword [eax], 0x87654321
    //to test an aligned write as well
    err = uc_emu_start(uc, 0x400015, 0x400000 + sizeof(PROGRAM), 0, 2);
    if (err) {
        printf("Expected failure on uc_emu_start() with error returned %u: %s\n",
                err, uc_strerror(err));
    } else {
        printf("UNEXPECTED uc_emu_start returned UC_ERR_OK\n");
    }
    printf("END execution - 2\n");

    printf("Verifying content at 0x400025 is unchanged\n");
    if (!uc_mem_read(uc, 0x400025, bytes, 4)) {
        printf(">>> Read 4 bytes from [0x%x] = 0x%x\n", (uint32_t)0x400025, *(uint32_t*) bytes);
        if (0x41414141 != *(uint32_t*) bytes) {
            printf("ERROR content in read only memory changed\n");
        } else {
            printf("SUCCESS content in read only memory unchanged\n");
        }
    } else {
        printf(">>> Failed to read 4 bytes from [0x%x]\n", (uint32_t)(esp - 4));
        return 4;
    }

    printf("Verifying content at 0x40002C is unchanged\n");
    if (!uc_mem_read(uc, 0x40002C, bytes, 4)) {
        printf(">>> Read 4 bytes from [0x%x] = 0x%x\n", (uint32_t)0x40002C, *(uint32_t*) bytes);
        if (0x42424242 != *(uint32_t*) bytes) {
            printf("ERROR content in read only memory changed\n");
        } else {
            printf("SUCCESS content in read only memory unchanged\n");
        }
    } else {
        printf(">>> Failed to read 4 bytes from [0x%x]\n", (uint32_t)(esp - 4));
        return 4;
    }

    printf("Verifying content at bottom of stack is readable and correct\n");
    if (!uc_mem_read(uc, esp - 4, bytes, 4)) {
        printf(">>> Read 4 bytes from [0x%x] = 0x%x\n", (uint32_t)(esp - 4), *(uint32_t*) bytes);
    } else {
        printf(">>> Failed to read 4 bytes from [0x%x]\n", (uint32_t)(esp - 4));
        return 4;
    }

    uc_close(uc);

    return 0;
}


// Create the list of possible values for a DIPswitch
static void InpDIPSWSelect()
{
}

int InpDIPSWCreate()
{
	if (bDrvOkay == 0) {									// No game is loaded
		return 1;
	}

	bOK = false;

	return 0;
}
/*----------------
Stuff to finish:
redo config stuff + add support for per game config files
decide how to add the sound code via the sound interface
add config options for video and sound
add dat.cpp and sshot.cpp

------------------*/
#include <psppower.h>
#include <pspgu.h>
#include <pspkernel.h>
#include <pspdebug.h>
#include <pspctrl.h>
#include <stdio.h>
#include <stdlib.h>
//#include <unistd.h>
//#include <fcntl.h>
#include <string.h>
#include <math.h>
#include "burner.h"

int nAppVirtualFps = 6000;			// App fps * 100
bool bRunPause=0;
bool bAlwaysProcessKeyboardInput=0;

/* Define the module info section */
PSP_MODULE_INFO("fbapsp", 0, 1, 0);
PSP_HEAP_SIZE_MAX();

#ifdef logging_build

static FILE *fp;

void log_printf(const char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    fprintf(fp, format, ap);
    va_end(ap);
//	fflush(fp);

}

#endif

/* Exit callback */
int exit_callback(int arg1, int arg2, void *common)
{
	//need to cleanup here
#ifdef logging_build
	fflush(fp);
	fclose(fp);
#endif
	scePowerSetClockFrequency(222,222,111);
	sceKernelExitGame();

	return 0;
}

/* Callback thread */
int CallbackThread(SceSize args, void *argp)
{
	int cbid;

	cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
	sceKernelRegisterExitCallback(cbid);

	sceKernelSleepThreadCB();

	return 0;
}

/* Sets up the callback thread and returns its thread id */
int SetupCallbacks(void)
{
	int thid = 0;

	thid = sceKernelCreateThread("update_thread", CallbackThread, 0x11, 0xFA0, THREAD_ATTR_USER, 0);
	if(thid >= 0)
	{
		sceKernelStartThread(thid, 0, 0);
	}

	return thid;
}

void init_emu(unsigned int gamenum)
{
 	bCheatsAllowed=false;
//	ConfigAppLoad();
//	ConfigAppSave();
	//CreateDirectory(".:\\cfg", NULL);
	//CreateDirectory(".:\\state", NULL);
	DrvInit(gamenum,0);
 }

void fbamain()
{
	unsigned int i=0;
	int menureturn=0;

#ifdef logging_build
	fp = fopen("fbalog.txt", "a");
#endif
	scePowerSetClockFrequency(333,333,166);

	BurnLibInit();
	// samsho 317
	// ffight 131
	// 2020bb 14
	nBurnDrvSelect = 131;  // game to start

	InputInit();
	init_emu(nBurnDrvSelect);

	RunMessageLoop();

	DrvExit();
	InputExit();

	ConfigAppSave();
	BurnLibExit();

}


ementById('gaia_loginform');
  }
  if (form && form.Passwd) {
  form.Passwd.focus();
  }
  }
  if (!/iPad|iPhone|iPod/.test(navigator.userAgent)) {
  gaia_attachEvent(window, 'load', gaia_setFocus);
  }
  })();
</script>
<script>
  var gaia_scrollToElement = function(element) {
  var calculateOffsetHeight = function(element) {
  var curtop = 0;
  if (element.offsetParent) {
  while (element) {
  curtop += element.offsetTop;
  element = element.offsetParent;
  }
  }
  return curtop;
  }
  var siginOffsetHeight = calculateOffsetHeight(element);
  var scrollHeight = siginOffsetHeight - window.innerHeight +
  element.clientHeight + 0.02 * window.innerHeight;
  window.scroll(0, scrollHeight);
  }
</script>
<script>
  function gaia_onLoginSubmit() {
  try {
  gaia.loginAutoRedirect.stop();
  } catch (err) {
  // do not prevent form from being submitted
  }
  try {
  document.bg.invoke(function(response) {
  document.getElementById('bgresponse').value = response;
  });
  } catch (err) {
  document.getElementById('bgresponse').value = '';
  }
  return true;
  }
  document.getElementById('gaia_loginform').onsubmit = gaia_onLoginSubmit;
  var signinButton = document.getElementById('signIn');
  gaia_attachEvent(window, 'load', function(){
  gaia_scrollToElement(signinButton);
  });
</script>

</body></html>
<!DOCTYPE html>
<html class="spaceway csstransforms csstransforms3d csstransitions"><head>
	<meta charset="utf-8">
	<link rel="stylesheet" type="text/css" href="https://x.myspacecdn.com/new/common/css/sprite.E7D46568E8E21DE30ABA7B1DFF5A8984.min.css"><link rel="stylesheet" type="text/css" href="https://x.myspacecdn.com/new/common/css/global.11F0106432F4BE76BA3CBBB8B6AF57FC.min.css"><link rel="stylesheet" type="text/css" href="https://x.myspacecdn.com/new/common/css/authentication.7BE42BF9F2E88714290E638C020D3F68.min.css">

<meta name="description"


String>>{};
          void addQueryParam(core.String n, core.String v) =>
              queryMap.putIfAbsent(n, () => []).add(v);

          if (query.isNotEmpty) {
            for (var part in query.split('&')) {
              final keyValue = part.split('=');
              addQueryParam(
                core.Uri.decodeQueryComponent(keyValue[0]),
                core.Uri.decodeQueryComponent(keyValue[1]),
              );
            }
          }
          unittest.expect(
            queryMap['fields']!.first,
            unittest.equals(arg_$fields),
          );

          final h = {'content-type': 'application/json; charset=utf-8'};
          final resp = convert.json.encode(buildAttributes());
          return async.Future.value(stringResponse(200, h, resp));
        }),
        true,
      );
      final response = await res.getGoogleUpdated(
        arg_name,
        $fields: arg_$fields,
      );
      checkAttributes(response as api.Attributes);
    });
  });
}
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: deprecated_member_use_from_same_package
// ignore_for_file: doc_directive_unknown
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_const_declarations
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unintended_html_in_doc_comment
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_string_interpolations
// ignore_for_file: unreachable_from_main
// ignore_for_file: unused_local_variable

import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;

import 'package:googleapis/dfareporting/v5.dart' as api;
import 'package:http/http.dart' as http;
import 'package:test/test.dart' as unittest;

import '../test_shared.dart';

core.List<core.String> buildUnnamed0() => ['foo', 'foo'];

void checkUnnamed0(core.List<core.String> o) {
  unittest.expect(o, unittest.hasLength(2));
  unittest.expect(o[0], unittest.equals('foo'));
  unittest.expect(o[1], unittest.equals('foo'));
}

core.List<core.String> buildUnnamed1() => ['foo', 'foo'];

void checkUnnamed1(core.List<core.String> o) {
  unittest.expect(o, unittest.hasLength(2));
  unittest.expect(o[0], unittest.equals('foo'));
  unittest.expect(o[1], unittest.equals('foo'));
}

core.int buildCounterAccount = 0;
api.Account buildAccount() {
  final o = api.Account();
  buildCounterAccount++;
  if (buildCounterAccount < 3) {
    o.accountPermissionIds = buildUnnamed0();
    o.accountProfile = 'foo';
    o.active = true;
    o.activeAdsLimitTier = 'foo';
    o.activeViewOptOut = true;
    o.availablePermissionIds = buildUnnamed1();
    o.countryId = 'foo';
    o.currencyId = 'foo';
    o.defaultCreativeSizeId = 'foo';
    o.description = 'foo';
    o.id = 'foo';
    o.kind = 'foo';
    o.locale = 'foo';
    o.maximu


for (size_t i = 0; i < cpus.size(); ++i) {
    for (size_t j = i + 1; j < cpus.size(); ++j) {

      alignas(64) std::atomic<int> seq1 = {-1};
      alignas(64) std::atomic<int> seq2 = {-1};

      auto t = std::thread([&] {
        pinThread(cpus[i]);

        if (preheat) {
          auto init = std::chrono::steady_clock::now();
          while (1) {
            auto now = std::chrono::steady_clock::now();
            if ((now - init).count() >= 200000000)
              break;
          }
        }

        for (int m = 0; m < nsamples; ++m) {
          if (!use_write) {
            for (int n = 0; n < 100; ++n) {
              while (seq1.load(std::memory_order_acquire) != n)
                ;
              seq2.store(n, std::memory_order_release);
            }
          } else {
            while (seq2.load(std::memory_order_acquire) != 0)
              ;
            seq2.store(1, std::memory_order_release);
            for (int n = 0; n < 100; ++n) {
              int cmp;
              do {
                cmp = 2 * n;
              } while (!seq1.compare_exchange_strong(cmp, cmp + 1));
            }
          }
        }
      });

      std::chrono::nanoseconds rtt = std::chrono::nanoseconds::max();

      pinThread(cpus[j]);

      if (preheat) {
        auto init = std::chrono::steady_clock::now();
        while (1) {
          auto now = std::chrono::steady_clock::now();
          if ((now - init).count() >= 200000000)
            break;
        }
      }

      for (int m = 0; m < nsamples; ++m) {
        seq1 = seq2 = -1;
        if (!use_write) {
          auto ts1 = std::chrono::steady_clock::now();
          for (int n = 0; n < 100; ++n) {
            seq1.store(n, std::memory_order_release);
            while (seq2.load(std::memory_order_acquire) != n)
              ;
          }
          auto ts2 = std::chrono::steady_clock::now();
          rtt = std::min(rtt, ts2 - ts1);
        } else {
          // wait for the other thread to be ready
          seq2.store(0, std::memory_order_release);
          while (seq2.load(std::memory_order_acquire) == 0)
            ;
          seq2.store(-1, std::memory_order_release);
          auto ts1 = std::chrono::steady_clock::now();
          for (int n = 0; n < 100; ++n) {
            int cmp;
            do {
              cmp = 2 * n - 1;
            } while (!seq1.compare_exchange_strong(cmp, cmp + 1));
          }
          // wait for the other thread to see the last value
          while (seq1.load(std::memory_order_acquire) != 199)
            ;
          auto ts2 = std::chrono::steady_clock::now();
          rtt = std::min(rtt, ts2 - ts1);
        }
      }

      t.join();

      data[{i, j}] = rtt / 2 / 100;
      data[{j, i}] = rtt / 2 / 100;
    }
  }

  if (plot) {
    std::cout
        << "set title \"


});

const wpl = Ci.nsIWebProgressListener;
const MockCertificate = {
  commonName: "cn",
  organization: "o",
  organizationalUnit: "ou",
  issuerCommonName: "issuerCN",
  issuerOrganization: "issuerO",
  issuerOrganizationUnit: "issuerOU",
  sha256Fingerprint: "qwertyuiopoiuytrewq",
  sha1Fingerprint: "qwertyuiop",
  validity: {
    notBeforeLocalDay: "yesterday",
    notAfterLocalDay: "tomorrow",
  },
};

// This *cannot* be used as an nsITransportSecurityInfo (since that interface is
// builtinclass) but the methods being tested aren't defined by XPCOM and aren't
// calling QueryInterface, so this usage is fine.
const MockSecurityInfo = {
  securityState: wpl.STATE_IS_SECURE,
  errorCode: 0,
  cipherName: "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256",
  // TLS_VERSION_1_2
  protocolVersion: 3,
  serverCert: MockCertificate,
};

function run_test() {
  const result = NetworkHelper.parseSecurityInfo(MockSecurityInfo, {});

  equal(result.state, "secure", "State is correct.");

  equal(
    result.cipherSuite,
    MockSecurityInfo.cipherName,
    "Cipher suite is correct."
  );

  equal(result.protocolVersion, "TLSv1.2", "Protocol version is correct.");

  deepEqual(
    result.cert,
    NetworkHelper.parseCertificateInfo(MockCertificate),
    "Certificate information is correct."
  );

  equal(result.hpkp, false, "HPKP is false when URI is not available.");
  equal(result.hsts, false, "HSTS is false when URI is not available.");
}
/* Any copyright is dedicated to the Public Domain.
   http://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

// Test for Web Console commands registration.

add_task(async function() {
  const tab = await addTab("data:text/html,

");
  const target = await getTargetForTab(tab);

  const webConsoleFront = await target.getFront("console");

  // Fetch WebConsoleCommands so that it is available for next Content Tasks
  await ContentTask.spawn(gBrowser.selectedBrowser, null, function() {
    const { require } = ChromeUtils.import(
      "resource://devtools/shared/Loader.jsm"
    );
    const {
      WebConsoleCommands,
    } = require("devtools/server/actors/webconsole/utils");

    // Bind the symbol on this in order to make it available for next tasks
    this.WebConsoleCommands = WebConsoleCommands;
  });

  await registerNewCommand(webConsoleFront);
  await wrapCommand(webConsoleFront);
  await unregisterCommand(webConsoleFront);
  await registerAccessor(webConsoleFront);
  await unregisterAfterOverridingTwice(webConsoleFront);
});

async function evaluateJSAndCheckResult(webConsoleFront, input, expected) {
  const response = await webConsoleFront.evaluateJSAsync(input);
  checkObject(response, expected);
}

async function registerNewCommand(webConsoleFront) {
  await ContentTask.spawn(gBrowser.selectedBrowser, null, function() {
    this.WebConsoleCommands.register("setFoo", (owner, value) => {
      owner.window.foo = value;
      return "ok";
    });

    ok(
      this.WebConsoleCommands.hasCommand("setFoo"),
      "The command should be registered"
    );
  });

  const command = "setFoo('bar')";
  await evaluateJSAndCheckResult(webConsoleFront, command, {
    input: command,
    result: "ok",
  });

  await ContentTask.spawn(gBrowser.selectedB


_blocked_by_vault_access_restriction\030\034 \001(\010B\003\340A\003\032-\n"
          + "\013LabelsEntry\022\013\n"
          + "\003key\030\001 \001(\t\022\r\n"
          + "\005value\030\002 \001(\t:\0028\001\"Q\n"
          + "\005State\022\025\n"
          + "\021STATE_UNSPECIFIED\020\000\022\014\n"
          + "\010CREATING\020\001\022\n"
          + "\n"
          + "\006ACTIVE\020\002\022\014\n"
          + "\010DELETING\020\003\022\t\n"
          + "\005ERROR\020\004:\236\001\352A\232\001\n"
          + "\"backupdr.googleapis.com/DataSource\022[projects/{project}/locations/{location}/"
          + "backupVaults/{backupvault}/dataSources/{datasource}*\013dataSources2\n"
          + "dataSourceB\021\n"
          + "\017source_resourceB\016\n"
          + "\014_create_timeB\016\n"
          + "\014_update_timeB\017\n\r"
          + "_backup_countB\007\n"
          + "\005_etagB\025\n"
          + "\023_total_stored_bytes\"\261\004\n"
          + "\020BackupConfigInfo\022Z\n"
          + "\021last_backup_state\030\001 \001(\0162:.google.cloud."
          + "backupdr.v1.BackupConfigInfo.LastBackupStateB\003\340A\003\022P\n"
          + "\'last_successful_backup_consistency_time\030\002"
          + " \001(\0132\032.google.protobuf.TimestampB\003\340A\003\0222\n"
          + "\021last_backup_error\030\003 \001(\0132\022.google.rpc.StatusB\003\340A\003\022F\n"
          + "\021gcp_backup_config\030\004"
          + " \001(\0132).google.cloud.backupdr.v1.GcpBackupConfigH\000\022_\n"
          + "\036backup_appliance_backup_config\030\005"
          + " \001(\01325.google.cloud.backupdr.v1.BackupApplianceBackupConfigH\000\"\200\001\n"
          + "\017LastBackupState\022!\n"
          + "\035LAST_BACKUP_STATE_UNSPECIFIED\020\000\022\030\n"
          + "\024FIRST_BACKUP_PENDING\020\001\022\r\n"
          + "\tSUCCEEDED\020\002\022\n\n"
          + "\006FAILED\020\003\022\025\n"
          + "\021PERMISSION_DENIED\020\004B\017\n\r"
          + "backup_config\"\244\002\n"
          + "\017GcpBackupConfig\022<\n"
          + "\013backup_plan\030\001 \001(\tB\'\372A$\n"
          + "\"backupdr.googleapis.com/BackupPlan\022\037\n"
          + "\027backup_plan_description\030\002 \001(\t\022S\n"
          + "\027backup_plan_association\030\003 \001(\tB2\372A/\n"
          + "-backupdr.googleapis.com/BackupPlanAssociation\022\031\n"
          + "\021backup_plan_rules\030\004 \003(\t\022!\n"
          + "\031backup_plan_revision_name\030\005 \001(\t\022\037\n"
          + "\027backup_plan_revision_id\030\006 \001(\t\"\272\001\n"
          +


c static <K, V> void putMapNoPrefix(String key, Map<K, V> valueMap, Duration expired) {
        putMap0(key, Boolean.FALSE, valueMap, expired);
    }

    /**
     * putMap基础方法
     *
     * @param key       缓存键
     * @param hasPrefix 是否默认前缀
     * @param valueMap  缓存值
     * @param expired   过期时间
     * @param <K>       泛型K
     * @param <V>       泛型V
     */
    private static <K, V> void putMap0(String key, Boolean hasPrefix, Map<K, V> valueMap, Duration expired) {
        verifyParameters(key, valueMap);
        RMap<K, V> map = REDISSON_CLIENT.getMap(Objects.equals(hasPrefix, Boolean.TRUE) ? KeyPrefixConstants.CACHE_MAP_PREFIX + key : key);
        map.putAll(valueMap);
        if (Objects.nonNull(expired)) {
            map.expire(expired);
        }
    }

    /**
     * 如果存在则设置Map类型缓存
     *
     * @param key      缓存键
     * @param valueMap 缓存值
     * @param <K>      泛型K
     * @param <V>      泛型V
     */
    public static <K, V> Boolean putMapIfExists(String key, Map<K, V> valueMap) {
        return putMapIfExists0(key, Boolean.TRUE, valueMap, null);
    }

    /**
     * 不需要默认前缀，如果存在则设置Map类型缓存
     *
     * @param key      缓存键
     * @param valueMap 缓存值
     * @param <K>      泛型K
     * @param <V>      泛型V
     */
    public static <K, V> Boolean putMapNoPrefixIfExists(String key, Map<K, V> valueMap) {
        return putMapIfExists0(key, Boolean.FALSE, valueMap, null);
    }

    /**
     * 如果存在则设置Map类型缓存，同时设置过期时间
     *
     * @param key      缓存键
     * @param valueMap 缓存值
     * @param expired  过期时间
     * @param <K>      泛型K
     * @param <V>      泛型V
     */
    public static <K, V> Boolean putMapIfExists(String key, Map<K, V> valueMap, Duration expired) {
        return putMapIfExists0(key, Boolean.TRUE, valueMap, expired);
    }

    /**
     * 不需要默认前缀，如果存在则设置Map类型缓存，同时设置过期时间
     *
     * @param key      缓存键
     * @param valueMap 缓存值
     * @param expired  过期时间
     * @param <K>      泛型K
     * @param <V>      泛型V
     */
    public static <K, V> Boolean putMapNoPrefixIfExists(String key, Map<K, V> valueMap, Duration expired) {
        return putMapIfExists0(key, Boolean.FALSE, valueMap, expired);
    }

    /**
     * putMapIfExists基础方法
     *
     * @param key       缓存键
     * @param hasPrefix 是否默认前缀
     * @param valueMap  缓存值
     * @param expired   过期时间
     * @param <K>      泛型K
     * @param <V>      泛型V
     */
    private static <K, V> Boolean putMapIfExists0(String key, Boolean hasPrefix, Map<K, V> valueMap, Duration expired


25, w1
  bn.mov    w26, w4
  jal       x1, mod_mul_320x128
  bn.mov    w0, w19

  /* w19 <= ([w2,w3] * w26) mod n = (k1 * alpha) mod n */
  bn.mov    w24, w2
  bn.mov    w25, w3
  jal       x1, mod_mul_320x128

  /* w0 <= (w0+w19) mod n = (k * alpha) mod n */
  bn.addm   w0, w0, w19

  /* w1 <= w0^-1 mod n = (k * alpha)^-1 mod n */
  jal       x1, mod_inv

  /* Store result. */
  li        x2, 1
  la        x3, kalpha_inv
  bn.sid    x2, 0(x3)

  /* Load masking parameter to w0 (for simulator testing). */
  la        x3, alpha
  bn.lid    x0, 0(x3)

.data

/*
Default data for simulator-based testing:
k (unmasked): 0x2648d0d248b70944dfd84c2f85ea5793729112e7cafa50abdf7ef8b7594fa2a1
k0: 0x7e8bb020f9bb74012c8d5cd1c0fe2d66bead5ed1210904c73a27d1b2cdf7c706d47c4a892130fb63
k1: 0x81744fde06448bfff9bb740087b8dbddde11e80c0bf8f1512c230bf7f965aef60b02ae2e381ea73e
modulus (p256 curve order): 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551

Expected result (kalpha_inv*alpha) mod n:
0x5dd1c65fc4eae6c1ec40027ef8a50479ab0ea16d84293f99bb401f0caac1e32b
*/

.balign 32
.globl k0
k0:
.word 0x2130fb63
.word 0xd47c4a89
.word 0xcdf7c706
.word 0x3a27d1b2
.word 0x210904c7
.word 0xbead5ed1
.word 0xc0fe2d66
.word 0x2c8d5cd1
.word 0xf9bb7401
.word 0x7e8bb020

.balign 32
.globl k1
k1:
.word 0x381ea73e
.word 0x0b02ae2e
.word 0xf965aef6
.word 0x2c230bf7
.word 0x0bf8f151
.word 0xde11e80c
.word 0x87b8dbdd
.word 0xf9bb7400
.word 0x06448bff
.word 0x81744fde

/* Output: (k*alpha)^-1 mod n (256 bits). */
.balign 32
.globl kalpha_inv
kalpha_inv:
.zero 32

/* Output: Masking parameter alpha (128 bits). */
.balign 32
.globl alpha
alpha:
.zero 32


_zapsDBISAREstimateSize(
  ZapsDBISAR object,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  var bytesCount = offsets.last;
  bytesCount += 3 + object.callback.length * 3;
  bytesCount += 3 + object.lnAddr.length * 3;
  bytesCount += 3 + object.lnURL.length * 3;
  bytesCount += 3 + object.nostrPubkey.length * 3;
  return bytesCount;
}

void _zapsDBISARSerialize(
  ZapsDBISAR object,
  IsarWriter writer,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  writer.writeBool(offsets[0], object.allowsNostr);
  writer.writeString(offsets[1], object.callback);
  writer.writeString(offsets[2], object.lnAddr);
  writer.writeString(offsets[3], object.lnURL);
  writer.writeLong(offsets[4], object.maxSendable);
  writer.writeLong(offsets[5], object.minSendable);
  writer.writeString(offsets[6], object.nostrPubkey);
}

ZapsDBISAR _zapsDBISARDeserialize(
  Id id,
  IsarReader reader,
  List<int> offsets,
  Map<Type, List<int>> allOffsets,
) {
  final object = ZapsDBISAR(
    allowsNostr: reader.readBoolOrNull(offsets[0]) ?? false,
    callback: reader.readStringOrNull(offsets[1]) ?? '',
    lnAddr: reader.readStringOrNull(offsets[2]) ?? '',
    lnURL: reader.readStringOrNull(offsets[3]) ?? '',
    maxSendable: reader.readLongOrNull(offsets[4]) ?? 0,
    minSendable: reader.readLongOrNull(offsets[5]) ?? 0,
    nostrPubkey: reader.readStringOrNull(offsets[6]) ?? '',
  );
  object.id = id;
  return object;
}

P _zapsDBISARDeserializeProp<P>(
  IsarReader reader,
  int propertyId,
  int offset,
  Map<Type, List<int>> allOffsets,
) {
  switch (propertyId) {
    case 0:
      return (reader.readBoolOrNull(offset) ?? false) as P;
    case 1:
      return (reader.readStringOrNull(offset) ?? '') as P;
    case 2:
      return (reader.readStringOrNull(offset) ?? '') as P;
    case 3:
      return (reader.readStringOrNull(offset) ?? '') as P;
    case 4:
      return (reader.readLongOrNull(offset) ?? 0) as P;
    case 5:
      return (reader.readLongOrNull(offset) ?? 0) as P;
    case 6:
      return (reader.readStringOrNull(offset) ?? '') as P;
    default:
      throw IsarError('Unknown property with id $propertyId');
  }
}

Id _zapsDBISARGetId(ZapsDBISAR object) {
  return object.id;
}

List<IsarLinkBase<dynamic>> _zapsDBISARGetLinks(ZapsDBISAR object) {
  return [];
}

void _zapsDBISARAttach(IsarCollection<dynamic> col, Id id, ZapsDBISAR object) {
  object.id = id;
}

extension ZapsDBISARByIndex on IsarCollection<ZapsDBISAR> {
  Future<ZapsDBISAR?> getByLnAddr(String lnAddr) {
    return getByIndex(r'lnAddr', [lnAddr]);
  }

  ZapsDBISAR? getByLnAddrSync(String lnAddr) {
    return getByIndexSync(r'lnAddr', [lnAddr]);
  }

  Future<bool> deleteByLnAddr(String lnAddr) {
    return deleteByIndex(r'lnAddr', [lnAddr]);
  }

  bool deleteByLnAddrSync(String lnAddr) {
    return deleteByIndexSync(r'lnAddr', [lnAddr]);
  }

  Future<


WhwDotW7g2b3zBgZeS5uvFH4dxf0tj0Rutw/640?wx_fmt=other&from=appmsg&wxfrom=5&wx_lazy=1&wx_co=1&tp=webp "")

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

内容仅用于学习交流自查使用，由于传播、利用本公众号所提供的
POC
信息及
POC对应脚本
而造成的任何直接或者间接的后果及损失，均由使用者本人负责，公众号nday poc及作者不为此承担任何责任，一旦造成后果请自行承担！如文章有侵权烦请及时告知，我们会立即删除文章并致歉。谢谢！

**00******

**产品简介**

圣乔ERP系统是杭州圣乔科技有限公司开发的一款企业级管理软件
，旨在为企业提供一套全面、集成化的管理解决方案，帮助企业实现资源的优化配置和高效利用。该系统集成了财务、人力资源、生产、销售、供应链等多个业务模块，实现了企业内外部信息的无缝连接和实时共享。适用于各种规模的企业，特别是需要实现资源优化配置、提高运营效率和管理水平的企业。它可以帮助企业解决传统管理方式中存在的信息孤岛、数据重复输入、信息传递滞后等问题，提高企业的整体竞争力。
**01******

**漏洞概述**

圣乔ERP系统 SingleRowQueryConvertor 接口存在SQL注入漏洞，未经身份验证的远程攻击者除了可以利用 SQL 注入漏洞获取数据库中的信息（例如，管理员后台密码、站点的用户个人信息）之外，甚至在高权限的情况可向服务器中写入木马，进一步获取服务器系统权限。
**02******

**搜索引擎**

FOFA:
```
title="圣乔ERP系统"
```

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

**03******

**漏洞复现**
```
POST /erp/dwr/call/plaincall/SingleRowQueryConvertor.queryForString.dwr HTTP/1.1
Host:
Content-Type: text/plain
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW


, false);
      return this;
   }
   off(key: string) {
      this.switch(key, true);
      return this;
   }
   mod(mods: ModRecord = {}) {
      Object.entries(mods).forEach(([k, v]) => {
         this.mods.set(k, v);
      });
      return this;
   }
   elt(element: string) {
      const bem = new Block(this.block, element);
      return bem;
   }
   list() {
      const classes = [this.base];
      this.mods.forEach((v, k) => {
         if (!v) return;
         classes.push(this.expand(k, v));
      });
      return classes;
   }
   className() {
      return this.list().join(" ");
   }
   apply(elt: HTMLElement) {
      if (this.originalClasses === null) this.originalClasses = [...elt.classList];
      this.originalClasses.concat(this.list()).forEach((c) => elt.classList.add(c));
   }
   expand(key: string, value: string | true): string {
      return `${this.base}--${key}${value === true ? "" : "_" + value}`;
   }
}
/*

Problem 20.

Given the positions of a white bishop and a black
pawn on the standard chess board, determine whether the bishop
can capture the pawn in one move.

The bishop has no restrictions in distance for each move,
but is limited to diagonal movement.

*/

// ------ Original Way of Solving ------
//***Couldn't figure out on my own. Original is Dylan's solution.

// function bishopAndPawn(bishop, pawn) {

//     let board = {
//         a: 1,
//         b: 2,
//         c: 3,
//         d: 4,
//         e: 5,
//         f: 6,
//         g: 7,
//         h: 8
//     };

//     const bishopX = board[bishop[0]];
//     const bishopY = parseInt(bishop[1]);
//     const pawnX = board[pawn[0]];
//     const pawnY = parseInt(pawn[1]);

//     if (bishopX + bishopY === pawnY + pawnX || bishopX + pawnY === pawnX + bishopY) {
//         return true;
//     }

//     return false;

// }

// ------ Refactored ------

function bishopAndPawn(bishop: string, pawn: string): boolean {
    let board = {
        'a': 1,
        'b': 2,
        'c': 3,
        'd': 4,
        'e': 5,
        'f': 6,
        'g': 7,
        'h': 8
    };

    return checkTopRight(bishop, pawn) ? true : checkTopLeft(bishop, pawn) ? true : checkBottomRight(bishop, pawn) ? true : checkBottomLeft(bishop, pawn) ? true : false;

    function checkTopRight(bishop, pawn) {
        let horizontal = +bishop[1];
        for (let i = board[bishop[0]]; i < 9; i++) {
            if (i === board[pawn[0]] && horizontal === +pawn[1]) {
                return true;
            }
            horizontal++;
        }
    }
    function checkTopLeft(bishop, pawn) {
        let horizontal = +bishop[1];
        for (let i = board[bishop[0]]; i > 0; i--) {
            if (i === board[pawn[0]] && horizontal === +pawn[1]) {
                return true;
            }
            horizontal++;
        }
    }
    function checkBottomRight(bishop, pawn) {
        let horizontal = +bishop[1];
        for (let i = board[bishop[0]]; i < 9; i++) {
            if (i === board[pawn[0]] && horizontal === +pawn[1]) {
                return true;
            }
            horizontal--;
        }
    }
    function checkBottomLeft(bishop, pawn) {
        let horizo


NumLayerInOls[i] = 1;
                    LayerIdInOls[i][0] = vps->vps_layer_id[i];
                }
                else if(vps->vps_ols_mode_idc <= 1 /*vps->vps_ols_mode_idc == 0 || vps->vps_ols_mode_idc == 1*/)
                {
                    NumLayerInOls[i] = i + 1;
                    for(j = 0; j < NumLayerInOls[i]; j++)
                    {
                        LayerIdInOls[i][j] = vps->vps_layer_id[j];
                    }
                }
                else if(vps->vps_ols_mode_idc == 2)
                {
                    for(j = 0, k = 0; k <= vps->vps_max_layers_minus1; k++)
                    {
                        if(layerIncludedInOlsFlag[i][k])
                            LayerIdInOls[i][j++] = vps->vps_layer_id[k];
                    }
                    NumLayerInOls[i] = j;
                }
                if(NumLayerInOls[i] > 1)
                {
                    //MultiLayerOlsIdx[i] = NumMultiLayerOlss;
                    NumMultiLayerOls++;
                }
            }
        }

        for(i = 0; i < NumMultiLayerOls; i++)
        {
            vps->vps_ols_dpb_pic_width[i] = bsGetUe(bs);
            vps->vps_ols_dpb_pic_height[i] = bsGetUe(bs);
            vps->vps_ols_dpb_chroma_format[i] = bsGetBits(bs, 2);
            vps->vps_ols_dpb_bitdepth_minus8[i] = bsGetUe(bs);
            if(VpsNumDpbParams > 1 && VpsNumDpbParams != NumMultiLayerOls)
            {
                vps->vps_ols_dpb_params_idx[i] = bsGetUe(bs);
            }
        }
        vps->vps_timing_hrd_params_present_flag = bsGetBit(bs);
        if(vps->vps_timing_hrd_params_present_flag)
        {
            general_timing_hrd_parameters(codec, bs);
            if(vps->vps_max_sublayers_minus1 > 0)
            {
                vps->vps_sublayer_cpb_params_present_flag = bsGetBit(bs);
            }
            vps->vps_num_ols_timing_hrd_params_minus1 = bsGetUe(bs);
            for(i = 0; i <= vps->vps_num_ols_timing_hrd_params_minus1; i++)
            {
                if(!vps->vps_default_ptl_dpb_hrd_max_tid_flag)
                {
                    vps->vps_hrd_max_tid[i] = bsGetBits(bs, 3);
                    const int firstSubLayer = vps->vps_sublayer_cpb_params_present_flag ? 0 : vps->vps_hrd_max_tid[i];
                    ols_timing_hrd_parameters(codec, bs, firstSubLayer, vps->vps_hrd_max_tid[i]);
                }
            }
            if(vps->vps_num_ols_timing_hrd_params_minus1 > 0 &&
               vps->vps_num_ols_timing_hrd_params_minus1+1 != 0)
            {
                for(i = 0; i < 0; i++)


}, ${JSON.stringify(
                      whatToAdd,
                      null,
                      0
                    )}]`
                  );
                  lastLinebreak = null;
                  console.log(
                    `1526 ${`\u001b[${31}m${`RESET`}\u001b[${39}m`} ${`\u001b[${33}m${`lastLinebreak`}\u001b[${39}m`} = ${JSON.stringify(
                      lastLinebreak,
                      null,
                      4
                    )}`
                  );
                } // else {
                //   console.log(
                //     `1419 didn't push because whitespace is between curlies`
                //   );
                // }
              } else {
                console.log(
                  `1539 ${`${`\u001b[${31}m${`██`}\u001b[${39}m`}${`\u001b[${33}m${`██`}\u001b[${39}m`}`.repeat(
                    10
                  )} - lastLinebreak = ${lastLinebreak}`
                );
                // countCharactersPerLine -= i - (lastLinebreak || 0);
              }
            }

            console.log(
              `1548 ${`\u001b[${33}m${`leftTagName`}\u001b[${39}m`} = ${leftTagName}`
            );
            // 2. put this current place into stage
            // =============================================================
            if (
              str[i].trim() &&
              (CHARS_BREAK_ON_THE_LEFT_OF_THEM.includes(str[i]) ||
                (str[~-i] &&
                  CHARS_BREAK_ON_THE_RIGHT_OF_THEM.includes(str[~-i]))) &&
              isStr(leftTagName) &&
              (!tagName || !opts.mindTheInlineTags.includes(tagName)) &&
              !(
                str[i] === "<" &&
                matchRight(str, i, opts.mindTheInlineTags, {
                  cb: (nextChar) => !nextChar || !/\w/.test(nextChar), // not a letter
                })
              ) &&
              !(
                str[i] === "<" &&
                matchRight(str, i, opts.mindTheInlineTags, {
                  trimCharsBeforeMatching: "/",
                  cb: (nextChar) => !nextChar || !/\w/.test(nextChar), // not a letter
                })
              )
            ) {
              stageFrom = i;
              stageTo = i;
              stageAdd = null;
              console.log(
                `1577 SET stage from = ${stageFrom}; stageTo = ${stageTo}; RESET "stageAdd = null"`
              );
            } else if (
              styleCommentStartedAt === null &&
              stageFrom !== null &&
              (withinInlineStyle ||
                !opts.mindTheInlineTags ||
                !Array.isArray(opts.mindTheInlineTags) ||
                (Array.isArray(opts.mindTheInlineTags.length) &&
                  !opts.mindTheInlineTags.length) ||
                !isStr(tagName) ||
                (Array.isArray(opts.mindTheInlineTags) &&
                  opts.mindTheInlineTags.length &&
                  isStr(tagName) &&
                  !opts.mindTheInlineTags.includes(tagName as string))) &&
              !(
                str[i] === "<" &&
                matchRight(str, i, opts.mindTheInlineTags, {
                  trimCharsBeforeMatching: "/",
                  cb: (nextChar) => !nextChar || !/\w/.test(nextChar), // not a letter
                })
              )
            ) {
              stageFrom = null;
              stageTo = null;
              stageAdd = null;
              console.log("1603 RESET all stage vars");
            }
          }
        } else if (opts.lineLengthLimit) {
          // countCharactersPerLine > opts.lineLengthLimit

          console.log(`1609 ${`\u001b[${36}m${`██`}\u001b[${39}m`}`);
          // LIMIT HAS BEEN EXCEEDED!
          // WE NEED TO BREAK RIGHT HE


glabel func_800A1344
/* B184E4 800A1344 27BDFF98 */  addiu $sp, $sp, -0x68
/* B184E8 800A1348 AFBF0024 */  sw    $ra, 0x24($sp)
/* B184EC 800A134C AFA40068 */  sw    $a0, 0x68($sp)
/* B184F0 800A1350 AFA5006C */  sw    $a1, 0x6c($sp)
/* B184F4 800A1354 AFA60070 */  sw    $a2, 0x70($sp)
/* B184F8 800A1358 AFA70074 */  sw    $a3, 0x74($sp)
/* B184FC 800A135C 8C850000 */  lw    $a1, ($a0)
/* B18500 800A1360 3C068014 */  lui   $a2, %hi(D_801400C8) # $a2, 0x8014
/* B18504 800A1364 24C600C8 */  addiu $a2, %lo(D_801400C8) # addiu $a2, $a2, 0xc8
/* B18508 800A1368 27A40038 */  addiu $a0, $sp, 0x38
/* B1850C 800A136C 24070434 */  li    $a3, 1076
/* B18510 800A1370 0C031AB1 */  jal   func_800C6AC4
/* B18514 800A1374 AFA50048 */   sw    $a1, 0x48($sp)
/* B18518 800A1378 0C034213 */  jal   Matrix_Push
/* B1851C 800A137C 00000000 */   nop
/* B18520 800A1380 8FB8006C */  lw    $t8, 0x6c($sp)
/* B18524 800A1384 8FAF0070 */  lw    $t7, 0x70($sp)
/* B18528 800A1388 3C0E8016 */  lui   $t6, %hi(gSegments)
/* B1852C 800A138C 0018C880 */  sll   $t9, $t8, 2
/* B18530 800A1390 01F94821 */  addu  $t1, $t7, $t9
/* B18534 800A1394 8D220000 */  lw    $v0, ($t1)
/* B18538 800A1398 270F0001 */  addiu $t7, $t8, 1
/* B1853C 800A139C 8FA90074 */  lw    $t1, 0x74($sp)
/* B18540 800A13A0 00025900 */  sll   $t3, $v0, 4
/* B18544 800A13A4 000B6702 */  srl   $t4, $t3, 0x1c
/* B18548 800A13A8 000C6880 */  sll   $t5, $t4, 2
/* B1854C 800A13AC 01CD7021 */  addu  $t6, $t6, $t5
/* B18550 800A13B0 8DCE6FA8 */  lw    $t6, %lo(gSegments)($t6)
/* B18554 800A13B4 3C0100FF */  lui   $at, (0x00FFFFFF >> 16) # lui $at, 0xff
/* B18558 800A13B8 000F5880 */  sll   $t3, $t7, 2
/* B1855C 800A13BC 3421FFFF */  ori   $at, (0x00FFFFFF & 0xFFFF) # ori $at, $at, 0xffff
/* B18560 800A13C0 016F5823 */  subu  $t3, $t3, $t7
/* B18564 800A13C4 000B5840 */  sll   $t3, $t3, 1
/* B18568 800A13


, also explain why you need it.
        NEVER ask the user if 'Provided Data' already has enough information. Do not mention the tool name in the response.
        Ask the user to provide the required parameters in "response" field of the JSON output. Do not ask for other information in any other field.
      ''');

    // Instructions about how to use agents
    if (!isPartOfChain) {
      buffer.writeln(
        "RULE TO USE AGENTS: If this tasks should be handled by multiple agents in the system, output a chain of agents in the logical sequence. This will be decided based on the available tools and available agents. If the tools available to you can't completely solve this task and the roles of available agents overlap with some part of the task and the prompt isn't of general nature that can be handled by any LLM/agent, then output the agents that should be used in the chain, in the sequential order of subtask hadnling.\n",
      );
    }

    buffer.writeln(
      "${"\nBased on the system instruction, chat history, tools and agents in the system, generate a response for the user. If a tool should be used for the response, include the tool name in the response, if parameters are required for a tool, include them in the response, if no parameters are required, do not include them. If no tool is available for the prompt, generate the response yourself. If agents should be used, output a chain of agents in the logical sequence. Give the response strictly in JSON, do not add anything extra to the response, just the parsable JSON. Do not include any text outside of the JSON. Order of action should be as follows: 1. Check all the available tools. \n2. If a tool or tools are found to respond to the prompt then output them in the provided JSON format. \n3. If a tool has a parameter that is required, deduce it from the given information and the prompt. If a parameters can not be deduced, ask the user to provide that paramter in the response field of the JSON. ONLY ASK FOR PARAMETERS IF THEY ARE REQUIRED, IF A PARAMETER IS NOT REQUIRED, DO NOT ASK FOR IT. DO NOT MENTION THE NAME OF THE TOOL, ONLY ASK FOR THE PARAMETER IN THE RESPONSE. Use the response field of the JSON to output the response or if you need additional information like a REQUIRED PARAMETER that can not be deduced. Hold a normal conversation and explain why you are asking for the parameter."}\n",
    );

    // If data is provided as input from some previous execution in the chain, add it to the prompt
    if (input != null && input.isNotEmpty && isPartOfChain) {
      buffer.writeln(
        "DO NOT ASK FOR ANY ADDITIONAL CONTEXT, WORK WITH THE DATA THAT IS PROVIDED TO YOU. Use this data to perform the task, if tools are to be used for the task, find the parameters from this data, if parameters can be extracted from this data, extract them, otherwise DO NOT ASK THE USER FOR THE PARAMETERS, try and solve the task using this only this data and the data already available to you. Your highest priority should be to use this data and infer any required infromation, DO NOT ASK FOR ANY ADDITIONAL INFORMATION. Provided Data: $input\n",
      );
    }

    if (!isPartOfChain) {
      buffer.writeln(
        "${"\n4. If this tasks involve multiple agents in the system, output a chain of agents in the logical sequence. \n5. If it does not involve multiple agents in the system, and the task can not be solved completely by the tools available for the prompt, generate the response yourself. \n6. Always verrify if the task can be solved by agents or t


otate(0deg);
  }
  100% {
    -webkit-transform: rotate(359deg);
    transform: rotate(359deg);
  }
}
.fa-rotate-90 {
  -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";
  -webkit-transform: rotate(90deg);
  -ms-transform: rotate(90deg);
  transform: rotate(90deg);
}
.fa-rotate-180 {
  -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";
  -webkit-transform: rotate(180deg);
  -ms-transform: rotate(180deg);
  transform: rotate(180deg);
}
.fa-rotate-270 {
  -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";
  -webkit-transform: rotate(270deg);
  -ms-transform: rotate(270deg);
  transform: rotate(270deg);
}
.fa-flip-horizontal {
  -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";
  -webkit-transform: scale(-1, 1);
  -ms-transform: scale(-1, 1);
  transform: scale(-1, 1);
}
.fa-flip-vertical {
  -ms-filter: "progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";
  -webkit-transform: scale(1, -1);
  -ms-transform: scale(1, -1);
  transform: scale(1, -1);
}
:root .fa-rotate-90,
:root .fa-rotate-180,
:root .fa-rotate-270,
:root .fa-flip-horizontal,
:root .fa-flip-vertical {
  filter: none;
}
.fa-stack {
  position: relative;
  display: inline-block;
  width: 2em;
  height: 2em;
  line-height: 2em;
  vertical-align: middle;
}
.fa-stack-1x,
.fa-stack-2x {
  position: absolute;
  left: 0;
  width: 100%;
  text-align: center;
}
.fa-stack-1x {
  line-height: inherit;
}
.fa-stack-2x {
  font-size: 2em;
}
.fa-inverse {
  color: #ffffff;
}
/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen
   readers do not read off random characters that represent icons */
.fa-glass:before {
  content: "\f000";
}
.fa-music:before {
  content: "\f001";
}
.fa-search:before {
  content: "\f002";
}
.fa-envelope-o:before {
  content: "\f003";
}
.fa-heart:before {
  content: "\f004";
}
.fa-star:before {
  content: "\f005";
}
.fa-star-o:before {
  content: "\f006";
}
.fa-user:before {
  content: "\f007";
}
.fa-film:before {
  content: "\f008";
}
.fa-th-large:before {
  content: "\f009";
}
.fa-th:before {
  content: "\f00a";
}
.fa-th-list:before {
  content: "\f00b";
}
.fa-check:before {
  content: "\f00c";
}
.fa-remove:before,
.fa-close:before,
.fa-times:before {
  content: "\f00d";
}
.fa-search-plus:before {
  content: "\f00e";
}
.fa-search-minus:before {
  content: "\f010";
}
.fa-power-off:


public class CommentsFragment extends Fragment {
	private String newsId;
	private ArrayList<CommentVO> comment_list;
	private Handler handler = new Handler();
	private ListView listView;
	private CommentsAdapter adapter;
	private LayoutInflater inflater;
	private View rootView;
	public CommentsFragment(String newsId) {
		this.newsId = newsId;
	}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState) {
		this.inflater = inflater;
		rootView = inflater.inflate(R.layout.fragment_comments, container,
				false);
		new CommentsDataThread().start();
		return rootView;
	}

	private void initView() {
		listView = (ListView) rootView.findViewById(R.id.comments_listview);
		((TextView)rootView.findViewById(R.id.no_comment)).setVisibility(View.GONE);
		adapter = new CommentsAdapter();
		listView.setAdapter(adapter);
	}

	class CommentsDataThread extends Thread {
		@Override
		public void run() {
			try {
				String comments = GetCommentsInterface.getNetData(newsId);
				HtmlResolving hResolving = new HtmlResolving();
				comment_list = hResolving.getCommentContent(comments);
				if (comment_list != null && comment_list.size() > 0) {
					handler.post(new Runnable() {
						@Override
						public void run() {
							initView();
						}
					});
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

	}

	public void onResume() {
	    super.onResume();
	    MobclickAgent.onPageStart("MainScreen"); //统计页面
	}
	public void onPause() {
	    super.onPause();
	    MobclickAgent.onPageEnd("MainScreen");
	}

	public class CommentsAdapter extends BaseAdapter {

		@Override
		public int getCount() {
			return comment_list.size();
		}

		@Override
		public Object getItem(int position) {
			return comment_list.get(position);
		}

		@Override
		public long getItemId(int position) {
			return position;
		}

		@Override
		public View getView(int position, View convertView, ViewGroup parent) {
			Holder holder;
			if (convertView == null) {
				convertView = inflater.inflate(R.layout.item_comments, null);
				holder = new Holder();
				holder.player = (TextView) convertView
						.findViewById(R.id.item_comment_player);
				holder.body = (TextView) convertView
						.findViewById(R.id.item_comment_body);
				holder.createTime = (TextView) convertView
						.findViewById(R.id.item_comment_create_time);
				convertView.setTag(holder);
			} else {
				holder = (Holder) convertView.getTag();
			}
			Typeface typeface = Typeface.createFromAsset(getActivity()
					.getAssets(), "font/Roboto-Light.ttf");
			holder.player.setText(comment_list.get(position).getName());
			holder.player.setTypeface(typeface);
			holder.body.setText(Html.fromHtml(comment_list.get(position)
					.getContent()));
			holder.body.setTypeface(typeface);
			holder.createTime.setText(comment_list.get(position).getTime());

			return convertView;
		}

		public class Holder {
			TextView player;
			TextView body;
			TextView createTime;
		}
	}

}
package com.hua.goddess.fragment;

import java.util.ArrayList;

import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.support.v4.app.Fragment;
import android.text.format.DateUtils;
import android


rl in new_completions.items():
            self.update_media_entry(media_key, status='completed', url=url)

        return new_completions

    def get_previous_media_results(self):
        return {
            media_key: media_info['url']
            for media_key, media_info in self.media.items()
            if media_info['status'] == 'completed'
        }

    @classmethod
    def create(cls, request):
        instance = cls(uuid.uuid4().hex)
        user_id = request.user.pk if request.user.is_authenticated else None
        instance.update_cache_entry(
            dict(user_id=user_id, media=dict()))
        return instance

    @classmethod
    def get_existing(cls, key, request):
        instance = cls(key)
        user_id = request.user.pk if request.user.is_authenticated else None
        if user_id != instance.cache_entry['user_id']:
            raise MediaRequestDenied("Wrong user.")
        return instance


itCode: VulkanDispatchingSystem.Drawer.() -> Unit) : VulkanDispatchingSystem.Drawer(pass), DefferedLightsRenderer {
        override val system: VulkanDispatchingSystem<*>
            get() = this@VulkanDefferedLightsDispatcher

        private val vertexBuffer: VulkanVertexBuffer

        init {
            drawerInitCode()

            val vertices = floatArrayOf(-1.0F, -3.0F, 3.0F, 1.0F, -1.0F, 1.0F)
            vertexBuffer = VulkanVertexBuffer(backend, vertices.size * 4L, MemoryUsagePattern.STATIC)

            MemoryStack.stackPush().use {
                val byteBuffer = MemoryStack.stackMalloc(vertices.size * 4)
                vertices.forEach { f -> byteBuffer.putFloat(f) }
                byteBuffer.flip()

                vertexBuffer.upload(byteBuffer)
            }
        }

        val vertexInputConfiguration = vertexInputConfiguration {
            binding {
                binding(0)
                stride(2 * 4)
                inputRate(VK_VERTEX_INPUT_RATE_VERTEX)
            }

            attribute {
                binding(0)
                location(program.vertexInputs.find { it.name == "vertexIn" }?.location!!)
                format(VK_FORMAT_R32G32_SFLOAT)
                offset(0)
            }
        }

        private val program = backend.shaderFactory.createProgram("pointLight", ShaderCompilationParameters(outputs = pass.declaration.outputs))
        private val pipeline = Pipeline(backend, program, pass, vertexInputConfiguration, Primitive.TRIANGLES, FaceCullingMode.DISABLED)

        override fun registerDrawingCommands(drawerWork: DrawerWork) {
            val work = drawerWork as DefferedLightsDrawerWork
            val context = work.drawerInstance.first
            val commandBuffer = work.cmdBuffer

            val bindingContexts = mutableListOf<VulkanShaderResourcesContext>()

            for (light in work.pointLights) {
                val bindingContext = context.getBindingContext(pipeline)
                bindingContexts.add(bindingContext)
                vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.handle)
                bindingContext.bindStructuredUBO("light", light)

                vkCmdBindVertexBuffers(commandBuffer, 0, stackLongs(vertexBuffer.handle), stackLongs(0))
                bindingContext.commitAndBind(commandBuffer)

                vkCmdDraw(commandBuffer, 3, 1, 0, 0)
            }

            context.frame.recyclingTasks.add {
                bindingContexts.forEach { it.recycle() }
            }
        }

        override fun cleanup() {
            pipeline.cleanup()
            program.cleanup()

            vertexBuffer.cleanup()
        }

    }

    override fun createDrawerForPass(pass: VulkanPass, drawerInitCode: VulkanDispatchingSystem.Drawer.() -> Unit) = Drawer(pass, drawerInitCode)

    /*fun sort(representations: Sequence<PointLight>, drawers: List<VulkanDispatchingSystem.Drawer<VkDefferedLightIR>>, workForDrawers: MutableMap<VulkanDispatchingSystem.Drawer<VkDefferedLightIR>, VkDefferedLightIR>) {
        val lists = drawers.associateWith { mutableListOf<PointLight>() }

        for (representation in representations) {
            for (drawer in drawers) {
                lists[drawer]!!.add(representation)
            }
        }

        for (entry in lists) {
            if (entry.value.isNotEmpty()) {
                workForDrawers[entry.key] = entry.value
            }
        }
    }*/
    class DefferedLightsDrawerWork(drawerInstance: Pair<VulkanPassInstance, VulkanDispatchingSystem.Drawer>) : DrawerWork(drawerInstance) {
        val pointLights =


();
            assert_eq!(erc1155.get(), false);
        }

        /// We test a simple use case of our contract.
        #[ink::test]
        fn it_works() {
            let mut erc1155 = Erc1155::new(false);
            assert_eq!(erc1155.get(), false);
            erc1155.flip();
            assert_eq!(erc1155.get(), true);
        }
    }
}

// Copyright (c) 2018 King's College London
// created by the Software Development Team <http://soft-dev.org/>
//
// The Universal Permissive License (UPL), Version 1.0
//
// Subject to the condition set forth below, permission is hereby granted to any
// person obtaining a copy of this software, associated documentation and/or
// data (collectively the "Software"), free of charge and under any and all
// copyright rights in the Software, and any and all patent rights owned or
// freely licensable by each licensor hereunder covering either (i) the
// unmodified Software as contributed to or provided by such licensor, or (ii)
// the Larger Works (as defined below), to deal in both
//
// (a) the Software, and
// (b) any piece of software and/or hardware listed in the lrgrwrks.txt file
// if one is included with the Software (each a "Larger Work" to which the Software
// is contributed by such licensors),
//
// without restriction, including without limitation the rights to copy, create
// derivative works of, display, perform, and distribute the Software and make,
// use, sell, offer for sale, import, export, have made, and have sold the
// Software and the Larger Work(s), and to sublicense the foregoing rights on
// either these or other terms.
//
// This license is subject to the following condition: The above copyright
// notice and either this complete permission notice or at a minimum a reference
// to the UPL must be included in all copies or substantial portions of the
// Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

#![warn(missing_docs)]

/// Compute the similarity of two subtrees in a `MappingStore`.
use std::collections::HashSet;
use std::fmt::Debug;

use ast::{DstNodeId, NodeId, SrcNodeId};
use matchers::MappingStore;

impl<T: Clone + Debug + Eq + ToString + 'static> MappingStore<T> {
    /// Dice measure of similarity between subtrees.
    pub fn dice_sim(&self, src: NodeId<SrcNodeId>, dst: NodeId<DstNodeId>) -> f64 {
        let n_src = src.breadth_first_traversal(&self.src_arena.borrow())
                       .count() as f64;
        let n_dst = dst.breadth_first_traversal(&self.dst_arena.borrow())
                       .count() as f64;
        let dice = 2.0 * f64::from(self.num_common_descendants(src, dst)) / (n_src + n_dst);
        debug_assert!(dice >= 0. && dice <= 1.);
        dice
    }

    /// Jaccard measure of similarity between subtrees.
    pub fn jaccard_sim(&self, src: NodeId<SrcNodeId>, dst: NodeId<DstNodeId>) -> f64 {
        let n_src = src.bread


��蓝色的愁三重梦」 • 梦符「愁永远之梦」 • 梦符「刈安色的迷梦」 • 梦符「刈安色的错综迷梦」 • 梦符「Dream Catcher」 • 梦符「苍蓝色的Dream Catcher」 • 梦符「梦我梦中」 • 月符「绀色的狂梦」 • 蝴蝶「Butterfly Supplantation」 • 超特急「Dream Express」 • <a href="/%E7%88%AC%E6%A2%A6%E3%80%8CCreeping_


rer.dir_doesnt_pass("feijoa");
	folders_suite(&filterer, "feijoa");
}

fn folders_suite(filterer: &IgnoreFilterer, name: &str) {
	filterer.file_does_pass("apples");
	filterer.file_does_pass("apples/carrots/cauliflowers/oranges");
	filterer.file_does_pass("apples/carrots/cauliflowers/artichokes/oranges");
	filterer.file_does_pass("apples/oranges/bananas");
	filterer.dir_does_pass("apples");
	filterer.dir_does_pass("apples/carrots/cauliflowers/oranges");
	filterer.dir_does_pass("apples/carrots/cauliflowers/artichokes/oranges");

	filterer.file_does_pass(&format!("raw-{}", name));
	filterer.dir_does_pass(&format!("raw-{}", name));
	filterer.file_does_pass(&format!("raw-{}/carrots/cauliflowers/oranges", name));
	filterer.file_does_pass(&format!("raw-{}/oranges/bananas", name));
	filterer.dir_does_pass(&format!("raw-{}/carrots/cauliflowers/oranges", name));
	filterer.file_does_pass(&format!(
		"raw-{}/carrots/cauliflowers/artichokes/oranges",
		name
	));
	filterer.dir_does_pass(&format!(
		"raw-{}/carrots/cauliflowers/artichokes/oranges",
		name
	));

	filterer.dir_doesnt_pass(&format!("{}/carrots/cauliflowers/oranges", name));
	filterer.dir_doesnt_pass(&format!("{}/carrots/cauliflowers/artichokes/oranges", name));
	filterer.file_doesnt_pass(&format!("{}/carrots/cauliflowers/oranges", name));
	filterer.file_doesnt_pass(&format!("{}/carrots/cauliflowers/artichokes/oranges", name));
	filterer.file_doesnt_pass(&format!("{}/oranges/bananas", name));
}

#[tokio::test]
async fn globs() {
	let filterer = filt("", &[file("globs")]).await;

	// Unmatched
	filterer.file_does_pass("FINAL-FINAL.docx");
	filterer.dir_does_pass("/a/folder");
	filterer.file_does_pass("rat");
	filterer.file_does_pass("foo/bar/rat");
	filterer.file_does_pass("/foo/bar/rat");

	// Cargo.toml
	filterer.file_doesnt_pass("Cargo.toml");
	filterer.dir_doesnt_pass("Cargo.toml");
	filterer.file_does_pass("Cargo.json");

	// package.json
	filterer.file_doesnt_pass("package.json");
	filterer.dir_doesnt_pass("package.json");
	filterer.file_does_pass("package.toml");

	// *.gemspec
	filterer.file_doesnt_pass("pearl.gemspec");
	filterer.dir_doesnt_pass("sapphire.gemspec");
	filterer.file_doesnt_pass(".gemspec");
	filterer.file_does_pass("diamond.gemspecial");

	// test-*
	filterer.file_doesnt_pass("test-unit");
	filterer.dir_doesnt_pass("test-integration");
	filterer.file_does_pass("tester-helper");

	// *.sw*


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

#ifndef VERIBLE_COMMON_TEXT_LINE_TERMINATOR_H_
#define VERIBLE_COMMON_TEXT_LINE_TERMINATOR_H_

#include <cstdint>
#include <ostream>
#include <string_view>

namespace verible {

enum class LineTerminatorStyle {
  // Line Feed `\n` (UNIX Style)
  kLF,
  // Carriage return + Line Feed `\r\n` (DOS Style)
  kCRLF,
};

// Emit the given line terminator to stream.
void EmitLineTerminator(LineTerminatorStyle style, std::ostream &stream);

// Look at "count_at_most" lines to decide if this is mostly LF or CRLF text.
LineTerminatorStyle GuessLineTerminator(std::string_view text,
                                        int32_t count_at_most);

}  // namespace verible

#endif  // VERIBLE_COMMON_TEXT_LINE_TERMINATOR_H_


nt-warning .page-item.disabled .page-link,.dark-mode .accent-warning .page-item.disabled a{background-color:#fff;border-color:#dee2e6;color:#6c757d}.dark-mode .accent-warning [class*=sidebar-dark-] .sidebar a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link){color:#c2c7d0}.dark-mode .accent-warning [class*=sidebar-dark-] .sidebar a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link):hover{color:#fff}.dark-mode .accent-warning [class*=sidebar-light-] .sidebar a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link){color:#343a40}.dark-mode .accent-warning [class*=sidebar-light-] .sidebar a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link):hover{color:#212529}.dark-mode .dark-mode.accent-warning .page-item .page-link:focus,.dark-mode .dark-mode.accent-warning .page-item .page-link:hover{color:#f4a62a}.dark-mode .accent-danger .btn-link,.dark-mode .accent-danger .nav-tabs .nav-link,.dark-mode .accent-danger a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link):not(.page-link):not(.badge):not(.btn){color:#e74c3c}.dark-mode .accent-danger .btn-link:hover,.dark-mode .accent-danger .nav-tabs .nav-link:hover,.dark-mode .accent-danger a:not(.dropdown-item):not(.btn-app):not(.nav-link):not(.brand-link):not(.page-link):not(.badge):not(.btn):hover{color:#bf2718}.dark-mode .accent-danger .dropdown-item.active,.dark-mode .accent-danger .dropdown-item:active{background-color:#e74c3c;color:#fff}.dark-mode .accent-danger .custom-control-input:checked~.custom-control-label::before{background-color:#e74c3c;border-color:#a82315}.dark-mode .accent-danger .custom-control-input:checked~.custom-control-label::after{background-image:url("data:image/svg+xml;charset=utf8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 8 8'%3E%3Cpath fill='%23fff' d='M6.564.75l-3.59 3.612-1.538-1.55L0 4.26 2.974 7.25 8 2.193z'/%3E%3C/svg%3E")}.dark-mode .accent-danger .custom-control-input:focus:not(:checked)~.custom-control-label::before,.dark-mode .accent-danger .custom-file-input:focus~.custom-file-label,.dark-mode .accent-danger .custom-select:focus,.dark-mode .accent-danger .form-control:focus:not(.is-invalid):not(.is-warning):not(.is-valid){border-color:#f5b4ae}.dark-mode .accent-danger .page-item .page-link{color:#e74c3c}.dark-mode .accent-danger .page-item.active .page-link,.dark-mode .accent-danger .page-item.active a{background-color:#e74c3c;border-color:#e74c3c;color:#fff}.dark-mode .accent-danger .page-item.disabled .page-link,.dark-mode .accent-danger .page-item.disabled a{background-color:#fff;border-color:#dee2e6;color:#6c757d}.dark-mode .accent-danger [class*=sidebar-dark-] .sidebar a:not(.dropdown-item):not(.btn-


nce, dt = sim.dt, speed = 5f)

                // We're going to aim at where the target will be, but we want to make sure to
                // compute
                leadingPos =
                    target.pos +
                        Vec2.makeWithAngleMag(
                            target.velocity.angle(),
                            min(altitude / 2, target.velocity.mag()),
                        )
                leadingVector = leadingPos - ship.pos

                if (altitude < landingAltitude) {
                    strategy = "LANDING"
                    // Strategy: zero thrust, face away, prepare for landing

                    ship.angle = (ship.pos - target.pos).angle() // point away from ground
                    ship.thrust = Vec2.Zero
                } else {
                    if (relativeSpeed < 0 || altitude > brakingDistance) {
                        strategy = "CHASING"
                        // Strategy: Make tracks. We are either a long way away, or falling behind.
                        ship.angle = leadingVector.angle()

                        ship.thrust = Vec2.makeWithAngleMag(ship.angle, 1.0f)
                    } else {
                        strategy = "APPROACHING"
                        // Strategy: Just slow down. If we get caught in the gravity well, it will
                        // gradually start pulling us more in the direction of the planet, which
                        // will create a graceful deceleration
                        ship.angle = (-ship.velocity).angle()

                        // We want to bleed off velocity over time. Specifically, relativeSpeed px/s
                        // over timeToTarget seconds.
                        val decel = relativeSpeed / timeToTarget
                        val decelThrust =
                            decel / MAIN_ENGINE_ACCEL * 0.9f // not quite slowing down enough
                        ship.thrust = Vec2.makeWithAngleMag(ship.angle, decelThrust)
                    }
                }
                debug = ("DV=%.0f D=%.0f T%+.1f").format(relativeSpeed, altitude, timeToTarget)
            }
            if (strategy != currentStrategy) {
                nextStrategyTime = sim.now + STRATEGY_MIN_TIME
            }
        }
    }

    override fun postUpdate(sim: Simulator, dt: Float) {
        if (!enabled) return
    }
}
package com.dede.sonimei.module.setting

import android.Manifest
import android.annotation.SuppressLint
import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import androidx.appcompat.app.AlertDialog
import androidx.preference.Preference
import androidx.preference.PreferenceFragmentCompat
import com.dede.sonimei.*
import com.dede.sonimei.data.Source
import com.dede.sonimei.module.home.AboutDialog
import com.dede.sonimei.module.local.LocalMusicFragment
import com.dede.sonimei.module.selector.*
import com.dede.sonimei.util.Logger
import com.dede.sonimei.util.extends.isNull
import com.dede.sonimei.util.info
import com.tbruyelle.rxpermissions2.RxPermissions
import org.jetbrains.anko.support.v4.defaultSharedPreferences
import org.jetbrains.anko.support.v4.startActivityForResult
import org.jetbrains.anko.support.v4.toast
import java.io.File
import java.io.FileFilter

/**
 * Created by hsh on 2018/5/17.
 */
class Settings : PreferenceFragmentCompat(),
        Logger,
        Preference.OnPreferenceChangeListener,
        Preference.OnPreferenceClickListener {

    companion object {
        const val KEY_CUSTOM_PATH = "custom_path"
        const val KEY_WIFI_DOWNLOAD = "wifi_download"
        const val KEY_DEFAULT_SEARCH_SOURCE = "default_search_source"
        const val KEY_BUG_REPORT = "bug_report"
        const val KEY_QQ_GROUP = "qq_group"
        const val KEY_IGNORE_60S = "ignore_60s"
        const val KEY_IGNORE_PATHS = "ignore_paths"
    }

    private val selectPathCode