  if job.total_steps > total_steps:
                    total_steps = job.total_steps
                    outer_bar.reset(total=job.total_steps)
                    outer_bar.update(job.current_step)
                    current_step = job.current_step
                if job.state in completed_states:
                    outer_bar.update(total_steps - current_step)
                    inner_bar.update(100 - previous_progress)
                    monitoring = False
                    break
                no_step_message = job.current_step_message
                if no_step_message != previous_message:
                    # Next phase of the job, reset progress bar
                    inner_bar.set_description(f"{no_step_message}", refresh=True)
                    inner_bar.reset(total=100)
                    previous_message = no_step_message
                    previous_progress = 0
                    outer_bar.update(job.current_step - current_step)
                    current_step = job.current_step

                incremental_progress = job.current_step_progress - previous_progress
                restrict(incremental_progress, min=0, max=100)
                inner_bar.update(incremental_progress)
                outer_bar.update(0)
                previous_progress = job.current_step_progress
                time.sleep(interval)
                t_elapsed = time.time() - t_start
            inner_bar.close()
            outer_bar.close()
        except KeyboardInterrupt:
            logging.info("Job monitoring interrupted, stopping...")
            job.update(session)
            inner_bar.close()
            outer_bar.close()
            return job
        if t_elapsed < timeout:
            logging.info(f"Job `{job.name}` finished, monitoring stopped. Total time elapsed: {t_elapsed:.1f} seconds")
        else:
            logging.info(
                f"Monitoring stopped after {t_elapsed:.1f} seconds due to timeout. Current job state: {job.state}"
            )
    return job


import os
import select
import socket
import ssl
import sys
import traceback

HOST = "127.0.0.1"
PORT = 8912

def sslProtocolVersion():
    # sslProtocolVersion
    if sys.version_info >= (2,7,13):
        # this means TLSv1 or higher
        # in the future change to
        # ssl.PROTOCOL_TLS1.2
        return ssl.PROTOCOL_TLS
    elif sys.version_info >= (2,7,9):
        # this means any SSL/TLS. SSLv2 and 3 are excluded with an option after context is created
        return ssl.PROTOCOL_SSLv23
    else:
        # this means TLSv1, there is no way to set "TLSv1 or higher" or
        # "TLSv1.2" in < 2.7.9
        return ssl.PROTOCOL_TLSv1

def sslProtocolCiphers():
    if ssl.OPENSSL_VERSION_NUMBER >= 0x10100000:
        return "AECDH-AES256-SHA@SECLEVEL=0"
    else:
        return "AECDH-AES256-SHA"

def connect():
    sock = socket.create_connection((HOST, PORT))
    return sock

def listen():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind((HOST, PORT))
    sock.listen(0)
    return sock

def sslHandshake(sock, server=False):
    if sys.version_info >= (2,7,9):
        context = ssl.SSLContext(sslProtocolVersion())
        context.set_ciphers(sslProtocolCiphers())
        context.set_ecdh_curve("secp256k1")
        context.check_hostname = False
        context.verify_mode = ssl.CERT_NONE
        context.options = ssl.OP_ALL | ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_SINGLE_ECDH_USE | ssl.OP_CIPHER_SERVER_PREFERENCE
        sslSock = context.wrap_socket(sock, server_side = server, do_handshake_on_connect=False)
    else:
        sslSock = ssl.wrap_socket(sock, keyfile = os.path.join('src', 'sslkeys', 'key.pem'), certfile = os.path.join('src', 'sslkeys', 'cert.pem'), server_side = server, ssl_version=sslProtocolVersion(), do_handshake_on_connect=False, ciphers='AECDH-AES256-SHA')

    while True:
        try:
            sslSock.do_handshake()
            break
        except ssl.SSLWantReadError:
            print "Waiting for SSL socket handhake read"
            select.select([sslSock], [], [], 10)
        except ssl.SSLWantWriteError:
            print "Waiting for SSL socket handhake write"
            select.select([], [sslSock], [], 10)
        except Exception:
            print "SSL socket handhake failed, shutting down connection"
            traceback.print_exc()
            return
    print "Success!"
    return sslSock

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print "Usage: ssltest.py client|server"
        sys.exit(0)
    elif sys.argv[1] == "server":
        serversock = listen()
        while True:
            print "Waiting for connection"
            sock, addr = serversock.accept()
            print "Got connection from %s:%i" % (addr[0], addr[1])
            sslSock = sslHandshake(sock, True)
            if sslSock:
                sslSock.shutdown(socket.SHUT_RDWR)
                sslSock.close()
    elif sys.argv[1] == "client":
        sock = connect()
        sslSock = sslHandshake(sock, False)
        if sslSock:
            sslSock.shutdown(socket.SHUT_RDWR)
            sslSock.close()
    else:
        print "Usage: ssltest.py client|server"
        sys.exit(0)


', CONCAT(Nome, ' ', Sobrenome, ' ', Apelido) AS 'Nome Completo',Especialidade,GrauAcademico as 'Grau Academico' FROM Funcionario WHERE Nome LIKE @keyword ";
            using (SqlConnection con = new SqlConnection(conexao.StringConexao))
            {
                SqlCommand cmd = new SqlCommand(query, con);
                cmd.Parameters.AddWithValue("@keyword", "%" + keyword + "%");
                SqlDataAdapter da = new SqlDataAdapter(cmd);
                da.Fill(dt);
            }
            return dt;
        }
        public DataTable PesquisarFuncionarioComChavePesagem(String keyword)
        {
            DataTable dt = new DataTable();
            string query = "SELECT FuncionarioID as 'Código do Veterinário', CONCAT(Nome, ' ', Sobrenome, ' ', Apelido) AS 'Nome Completo',Especialidade,GrauAcademico as 'Grau Academico' FROM Funcionario WHERE Nome LIKE @keyword ";
            using (SqlConnection con = new SqlConnection(conexao.StringConexao))
            {
                SqlCommand cmd = new SqlCommand(query, con);
                cmd.Parameters.AddWithValue("@keyword", "%" + keyword + "%");
                SqlDataAdapter da = new SqlDataAdapter(cmd);
                da.Fill(dt);
            }
            return dt;
        }

        public Mod


 to run after appending elements to root
  // because we need to actual mounted height.
  Spacer(document, root, {
    space: pageHeaderContainer.offsetHeight.toString(10),
  });
}

module.exports = PageHeader;
const Spacer = require('./Spacer.js');
const theme = require('../theme.js');

/**
 * @typedef {Object} RuntimeErrorHeaderProps
 * @property {number} currentErrorIndex
 * @property {number} totalErrors
 */

/**
 * A fixed header that shows the total runtime error count.
 * @param {Document} document
 * @param {HTMLElement} root
 * @param {RuntimeErrorHeaderProps} props
 * @returns {void}
 */
function RuntimeErrorHeader(document, root, props) {
  const header = document.createElement('div');
  header.innerText = `Error ${props.currentErrorIndex + 1} of ${props.totalErrors}`;
  header.style.backgroundColor = theme.red;
  header.style.color = theme.white;
  header.style.fontWeight = '500';
  header.style.height = '2.5rem';
  header.style.left = '0';
  header.style.lineHeight = '2.5rem';
  header.style.position = 'fixed';
  header.style.textAlign = 'center';
  header.style.top = '0';
  header.style.width = '100vw';
  header.style.zIndex = '2';

  root.appendChild(header);

  Spacer(document, root, { space: '2.5rem' });
}

module.exports = RuntimeErrorHeader;
"use strict";

;(function() {

	var root = this;
	var previous_emoji = root.EmojiConvertor;

	/**
	 * @global
	 * @namespace
	 */

	var emoji = function(){

		var self = this;

		/**
		 * The set of images to use for graphical emoji.
		 *
		 * @memberof emoji
		 * @type {string}
		 */
		self.img_set = 'apple';

		/**
		 * Configuration details for different image sets. This includes a path to a directory containing the
		 * individual images (`path`) and a URL to sprite sheets (`sheet`). All of these images can be found
		 * in the [emoji-data repository]{@link https://github.com/iamcal/emoji-data}. Using a CDN for these
		 * is not a bad idea.
		 *
		 * @memberof emoji
		 * @type {object}
		 */
		self.img_sets = {
			'apple' : {'path' : '/emoji-data/img-apple-64/', 'sheet' : '/emoji-data/sheet_apple_64.png', 'sheet_size' : 64, 'mask' : 1},
			'google' : {'path' : '/emoji-data/img-google-64/', 'sheet' : '/emoji-data/sheet_google_64.png', 'sheet_size' : 64, 'mask' : 2},
			'twitter' : {'path' : '/emoji-data/img-twitter-64/', 'sheet' : '/emoji-data/sheet_twitter_64.png', 'sheet_size' : 64, 'mask' : 4},
			'emojione' : {'path' : '/emoji-data/img-emojione-64/', 'sheet' : '/emoji-data/sheet_emojione_64.png', 'sheet_size' : 64, 'mask' : 8},
			'facebook' : {'path' : '/emoji-data/img-facebook-64/', 'sheet' : '/emoji-data/sheet_facebook_64.png', 'sheet_size' : 64, 'mask' : 16},
			'messenger' : {'path' : '/emoji-data/img-messenger-64/', 'sheet' : '/emoji-data/sheet_messenger_64.png', 'sheet_size' : 64, 'mask' : 32},
		};

		/**
		 * Use a CSS class instead of specifying a sprite or background image for
		 * the span representing the emoticon. This requires a CSS sheet with
		 * emoticon data-uris.
		 *
		 * @memberof emoji
		 * @type bool
		 * @todo document how


data read in, calculate the entry tree
            if (MapType == 1)
            {
                for (var idx = 0; idx < Entries; idx++)
                {
                    var last = 0.0;
                    var idxDiv = 1;
                    for (var i = 0; i < Dimensions; i++)
                    {
                        var moff = (idx / idxDiv) % lookupValueCount;
                        var value = (float)multiplicands[moff] * deltaValue + minValue + last;
                        lookupTable[idx * Dimensions + i] = (float)value;

                        if (sequence_p) last = value;

                        idxDiv *= lookupValueCount;
                    }
                }
            }
            else
            {
                for (var idx = 0; idx < Entries; idx++)
                {
                    var last = 0.0;
                    var moff = idx * Dimensions;
                    for (var i = 0; i < Dimensions; i++)
                    {
                        var value = multiplicands[moff] * deltaValue + minValue + last;
                        lookupTable[idx * Dimensions + i] = (float)value;

                        if (sequence_p) last = value;

                        ++moff;
                    }
                }
            }

            _lookupTable = lookupTable;
        }

        int lookup


gen_ty_3,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rte_flow_conv_rule__bindgen_ty_1 {
    #[doc = "< RO attributes."]
    pub attr_ro: *const rte_flow_attr,
    #[doc = "< Attributes."]
    pub attr: *mut rte_flow_attr,
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_rte_flow_conv_rule__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<rte_flow_conv_rule__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(rte_flow_conv_rule__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<rte_flow_conv_rule__bindgen_ty_1>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rte_flow_conv_rule__bindgen_ty_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<rte_flow_conv_rule__bindgen_ty_1>())).attr_ro as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rte_flow_conv_rule__bindgen_ty_1),
            "::",
            stringify!(attr_ro)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<rte_flow_conv_rule__bindgen_ty_1>())).attr as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rte_flow_conv_rule__bindgen_ty_1),
            "::",
            stringify!(attr)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union rte_flow_conv_rule__bindgen_ty_2 {
    #[doc = "< RO pattern."]
    pub pattern_ro: *const rte_flow_item,
    #[doc = "< Pattern items."]
    pub pattern: *mut rte_flow_item,
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_rte_flow_conv_rule__bindgen_ty_2() {
    assert_eq!(
        ::std::mem::size_of::<rte_flow_conv_rule__bindgen_ty_2>(),
        8usize,
        concat!("Size of: ", stringify!(rte_flow_conv_rule__bindgen_ty_2))
    );
    assert_eq!(
        ::std::mem::align_of::<rte_flow_conv_rule__bindgen_ty_2>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(rte_flow_conv_rule__bindgen_ty_2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<rte_flow_conv_rule__bindgen_ty_2>())).pattern_ro as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(rte_flow_conv_rule__bindgen_ty_2),
            "::",
            stringify!(pattern_ro)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<rte_flow_conv_rule__bindgen_ty_2>())).pattern as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stri


'IF',
    't': 10,
    'd': '当逻辑表达式的值为 TRUE 时返回一个值，而当其为 FALSE 时返回另一个值。',
    'a': '当逻辑表达式的值为 TRUE 时返回一个值，而当其为 FALSE 时返回另一个值。',
    'm': [2, 3],
    'p': [{
        'name': 'logical_test',
        'detail': '一个表达式或对包含表达式的单元格的引用，该表达式代表某种逻辑值（即TRUE或FALSE）。',
        'example': 'A2 = "foo"',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangeall'
    }, {
        'name': 'value_if_true',
        'detail': '当逻辑表达式为TRUE时的返回值。',
        'example': '"A2 is foo"',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangeall'
    }, {
        'name': 'value_if_false',
        'detail': '[可选 - 默认为空白] - 当逻辑表达式等于FALSE时的函数返回值。',
        'example': '"A2 was false"',
        'require': 'o',
        'repeat': 'n',
        'type': 'rangeall'
    }]
}, {
    'n': 'OR',
    't': 10,
    'd': '只要有一个参数的计算结果为 TRUE 时，返回 TRUE；所有参数的计算结果为 FALSE，即返回 FALSE。',
    'a': '只要有一个参数的计算结果为 TRUE 时，返回 TRUE；所有参数的计算结果为 FALSE，即返回 FALSE。',
    'm': [1, 255],
    'p': [{
        'name': 'logical1',
        'detail': '要测试的第一个条件，其计算结果可以为 TRUE 或 FALSE。',
        'example': 'A2 = "foo"',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangeall'
    }, {
        'name': '逻辑表达式2',
        'detail': '[可选] - 其他表达式或对包含表达式的单元格的引用，这些表达式代表某种逻辑值（即TRUE或FALSE）或者可以强制转换为逻辑值。',
        'example': ' A3 = "bar"',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangeall'
    }]
}, {
    'n': 'NE',
    't': 11,
    'd': '如果指定的值不相等，则返回“TRUE”；否则返回“FALSE”。相当于“<>”运算符。',
    'a': '如果指定的值不相等，则返回“TRUE”；否则返回“FALSE”。相当于“<>”运算符。',
    'm': [2, 2],
    'p': [{
        'name': 'value1',
        'detail': '第一个值。',
        'example': 'A2',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangeall'
    }, {
        'name': 'value2',
        'detail': '要检查是否与 value1 不相等的值。',
        'example': 'A3',
        'require': 'm',
        'repeat': 'n',
        'type': 'rangeall'
    }]
}, {
    'n': 'EQ',
    't': 11,
    'd': '如果


vigator.onLine) {
        setTimeout(() => {
          window.location.reload();
        }, 1000);
      }
    </script>

<form action="/submit" method="post" data-testid="testForm" id="testForm">
    Text:
    <input type="text" id="text" name="text" value="text value">

    Password:
    <input type="password" id="password" name="password" value="password value">

    Email:
    <input type="email" id="email" name="email" value="email@test.com">

    Number:
    <input type="number" id="number" name="number" value="12345">

    Date:
    <input type="date" id="date" name="date" value="2023-12-16">

    Time:
    <input type="time" id="time" name="time" value="10:30">

    Range:
    <input type="range" id="range" name="range" value="60">

    Color:
    <input type="color" id="color" name="color" value="#000000">

    Checkbox:
    <input type="checkbox" id="checkbox" name="checkbox" checked>

    Radio:
    <input type="radio" id="radio1" name="radio" value="option1">
    Option 1
    <input type="radio" id="radio2" name="radio" value="option2" checked>
    Option 2

    <input type="radio" id="radio3" name="radio" value="option3">
    Option 3

    File:
    <input type="file" id="file" name="file">

    Textarea:
    <textarea id="textarea" name="textarea">textarea value</textarea>

    Select:
    <select id="select" name="select">
        <option value="option1">Option 1</option>
        <option value="option2" selected>Option 2</option>
        <option value="option3">Option 3</option>
    </select>

    Hidden:
    <input type="hidden" id="hidden" name="hidden" value="hiddenValue">

    Submit:
    <input type="submit" id="submit" value="Submit">

    Reset:
    <input type="reset" id="reset" value="Reset">

    <select id="multiselect" data-testid="multiselect" name="multiselect[]" multiple>
        <option value="a" selected>a</option>
        <option value="b" selected>b</option>
    </select>

    <input type="checkbox" name="checkboxGroup[]" value="option1" id="checkboxGroup-1" checked> Option 1
    <input type="checkbox" name="checkboxGroup[]" value="option2" id="checkboxGroup-2" checked> Option 2
    <input type="checkbox" name="checkboxGroup[]" value="option3" id="checkboxGroup-3" checked> Option 3

    <input type="submit" name="button" value="value">
    <button type="submit" name="button2">value</button>

Disabled

    <input type="text" name="text-disabled" value="value" disabled>


__PIN__API.html#g5ae022cf68f790ab7df956253d3536a7">SIGNAL_INTERCEPT_CALLBACK
           fun,

          VOID *
           val

          )

Takes over ownership of a signal for the tool and establishes a tool handler for the signal. Tools should never call sigaction() directly to handle signals.

Use this function to take over "ownership" of a signal. If you want to be notified when the application receives a signal, use PIN_AddContextChangeFunction() instead.

Tools should take care when intercepting signals, because this can adversely affect the application if it also uses the signal. The application is still allowed to set up its own handler for an intercepted signal. However, the application is prevented from attempts to block the signal.

When an intercepted signal is received, the tool's handler is called first. The tool's handler then decides whether the signal should be forwarded to the application's handler (if any).

A tool can set only one "intercept" handler for a particular signal, so a new handler overwrites any previous handler for the same signal. To disable a handler, pass a NULL function pointer.

Parameters:

	sig 	The signal number to handle.

	fun 	The tool's handler function, or NULL to return ownership of the signal back to the application.

	val 	Value to pass to the handler function.

Returns:

TRUE if succeeds, FALSE otherwise

Availability:

Mode: JIT

 O/S: Linux

 CPU: All

Note:

Intercepting a signal immediately forces the current thread to unblock that signal. This ensures that the application cannot prevent the tool from receiving the signal. Any future threads that the application creates will also be prevented from blocking the signal. However, if there are existing threads in the application when the tool intercepts a signal, those threads will not be prevented from blocking the intercepted signal until some future time. There is no guarantee on when the other thread


e
 *      r13 - free to use
 *	cr7 - Result of comparison with PAGE_OFFSET
 *	MMUCR - loaded with proper value when we get here
 *	Upon exit, we reload everything and RFI.
 */
finish_tlb_load_47x:
	/* Combine RPN & ERPN an write WS 1 */
	rlwimi	r11,r12,0,0,31-PAGE_SHIFT
	tlbwe	r11,r13,1

	/* And make up word 2 */
	li	r10,0xf84			/* Mask to apply from PTE */
	rlwimi	r10,r12,29,30,31		/* DIRTY,READ -> SW,SR position */
	and	r11,r12,r10			/* Mask PTE bits to keep */
	bge	cr7,1f			/* User page ? no, leave U bits empty */
	rlwimi	r11,r11,3,26,28			/* yes, copy S bits to U */
	rlwinm	r11,r11,0,~PPC47x_TLB2_SX	/* Clear SX if User page */
1:	tlbwe	r11,r13,2

	/* Done...restore registers and get out of here.
	*/
	mfspr	r11, SPRN_SPRG_RSCRATCH4
	mtcr	r11
	mfspr	r13, SPRN_SPRG_RSCRATCH3
	mfspr	r12, SPRN_SPRG_RSCRATCH2
	mfspr	r11, SPRN_SPRG_RSCRATCH1
	mfspr	r10, SPRN_SPRG_RSCRATCH0
	rfi

#endif /* CONFIG_PPC_47x */

	/* Debug Interrupt */
	/*
	 * This statement needs to exist at the end of the IVPR
	 * definition just in case you end up taking a debug
	 * exception within another exception.
	 */
	DEBUG_CRIT_EXCEPTION

interrupt_end:

/*
 * Global functions
 */

/*
 * Adjust the machine check IVOR on 440A cores
 */
_GLOBAL(__fixup_440A_mcheck)
	li	r3,MachineCheckA@l
	mtspr	SPRN_IVOR1,r3
	sync
	blr

/*
 * Init CPU state. This is called at boot time or for secondary CPUs
 * to setup initial TLB entries, setup IVORs, etc...
 *
 */
_GLOBAL(init_cpu_state)
	mflr	r22
#ifdef CONFIG_PPC_47x
	/* We use the PVR to differentiate 44x cores from 476 */
	mfspr	r3,SPRN_PVR
	srwi	r3,r3,16
	cmplwi	cr0,r3,PVR_476FPE@h
	beq	head_start_47x
	cmplwi	cr0,r3,PVR_476@h
	beq	head_start_47x
	cmplwi	cr0,r3,PVR_476_ISS@h
	beq	head_start_47x
#endif /* CONFIG_PPC_47x */

/*
 * In case the firmware didn't do it, we apply some workarounds
 * that are good for all 440 core variants here
 */
	mfspr	r3,SPRN_CCR0
	rlwinm	r3,r3,0,0,27	/* disable icache prefetch */
	isync
	mtspr	SPRN_CCR0,r3
	isync
	sync

/*
 * Set up the initial MMU state for 44x
 *
 * We are still executing code at the virtual address
 * mappings set by the firmware for the base of RAM.
 *
 * We first invalidate all TLB entries but the one
 * we are running from.  We then load the KERNELBASE
 * mappings so we can begin to use kernel addresses


                curveTo(19.55f, 3.0f, 21.0f, 4.46f, 21.0f, 6.25f)
                verticalLineToRelative(11.5f)
                curveToRelative(0.0f, 1.8f, -1.46f, 3.25f, -3.25f, 3.25f)
                lineTo(6.25f, 21.0f)
                arcTo(3.25f, 3.25f, 0.0f, false, true, 3.0f, 17.75f)
                verticalLineToRelative(-5.77f)
                close()
                moveTo(18.33f, 19.4f)
                lineTo(12.53f, 13.71f)
                arcToRelative(0.75f, 0.75f, 0.0f, false, false, -0.97f, -0.07f)
                lineToRelative(-0.08f, 0.07f)
                lineToRelative(-5.81f, 5.7f)
                curveToRelative(0.18f, 0.06f, 0.38f, 0.09f, 0.58f, 0.09f)
                horizontalLineToRelative(11.5f)
                curveToRelative(0.2f, 0.0f, 0.4f, -0.03f, 0.58f, -0.1f)
                close()
                moveTo(15.25f, 6.5f)
                arcToRelative(2.25f, 2.25f, 0.0f, true, true, 0.0f, 4.5f)
                arcToRelative(2.25f, 2.25f, 0.0f, false, true, 0.0f, -4.5f)
                close()
                moveTo(15.25f, 8.0f)
                arcToRelative(0.75f, 0.75f, 0.0f, true, false, 0.0f, 1.5f)
                arcToRelative(0.75f, 0.75f, 0.0f, false, false, 0.0f, -1.5f)
                close()
            }
        }
        return _imageArrowForward!!
    }

private var _imageArrowForward: ImageVector? = null

package io.github.composefluent.icons.regular

import androidx.compose.ui.graphics.vector.ImageVector
import io.github.composefluent.icons.Icons
import io.github.composefluent.icons.fluentIcon
import io.github.composefluent.icons.fluentPath

public val Icons.Regular.TextIndentDecreaseLtrRotate270: ImageVector
    get() {
        if (_textIndentDecreaseLtrRotate270 != null) {
            return _textIndentDecreaseLtrRotate270!!
        }
        _textIndentDecreaseLtrRotate270 = fluentIcon(name =
                "Regular.TextIndentDecreaseLtrRotate270") {
            fluentPath {
                moveTo(16.0f, 6.25f)
                arcToRelative(0.75f, 0.75f, 0.0f, false, true, 1.5f, 0.0f)
                verticalLineToRelative(9.0f)
                arcToRelative(0.75f, 0.75f, 0.0f, false, true, -1.5f, 0.0f)
                verticalLineToRelative(-9.0f)
                close()
                moveTo(11.22f, 21.28f)
                lineTo(9.22f, 19.28f)
                arcToRelative(0.75f, 0.75f, 0.0f, false, true, 0.98f, -1.13f)
                lineToRelative(0.08f, 0.07f)
                lineToRelative(1.47f, 1.47f)
                lineToRelative(1.47f, -1.47f)
                arcToRelative(0.75f, 0.75f, 0.0f, false, true, 1.


�; ) HANGUL SYLLABLE KYAM
CEBD;CEBD;110F 1163 11B8;CEBD;110F 1163 11B8; # (캽; 캽; 캽; 캽; 캽; ) HANGUL SYLLABLE KYAB
CEBE;CEBE;110F 1163 11B9;CEBE;110F 1163 11B9; # (캾; 캾; 캾; 캾; 캾; ) HANGUL SYLLABLE KYABS
CEBF;CEBF;110F 1163 11BA;CEBF;110F 1163 11BA; # (캿; 캿; 캿; 캿; 캿; ) HANGUL SYLLABLE KYAS
CEC0;CEC0;110F 1163 11BB;CEC0;110F 1163 11BB; # (컀; 컀; 컀; 컀; 컀; ) HANGUL SYLLABLE KYASS
CEC1;CEC1;110F 1163 11BC;CEC1;110F 1163 11BC; # (컁; 컁; 컁; 컁; 컁; ) HANGUL SYLLABLE KYANG
CEC2;CEC2;110F 1163 11BD;CEC2;110F 1163 11BD; # (컂; 컂; 컂; 컂; 컂; ) HANGUL SYLLABLE KYAJ
CEC3;CEC3;110F 1163 11BE;CEC3;110F 1163 11BE; # (컃; 컃; 컃; 컃; 컃; ) HANGUL SYLLABLE KYAC
CEC4;CEC4;110F 1163 11BF;CEC4;110F 1163 11BF; # (컄; 컄; 컄; 컄; 컄; ) HANGUL SYLLABLE KYAK
CEC5;CEC5;110F 1163 11C0;CEC5;110F 1163 11C0; # (컅; 컅; 컅; 컅; 컅; ) HANGUL SYLLABLE KYAT
CEC6;CEC6;110F 1163 11C1;CEC6;110F 1163 11C1; # (컆; 컆; 컆; 컆; 컆; ) HANGUL SYLLABLE KYAP
CEC7;CEC7;110F 1163 11C2;CEC7;110F 1163 11C2; # (컇; 컇; 컇; 컇; 컇; ) HANGUL SYLLABLE KYAH
CEC8;CEC8;110F 1164;CEC8;110F 1164; # (컈; 컈; 컈; 컈; 컈; ) HANGUL SYLLABLE KYAE
CEC9;CEC9;110F 1164 11A8;CEC9;110F 1164 11A8; # (컉; 컉; 컉; 컉; 컉; ) HANGUL SYLLABLE KYAEG
CECA;CECA;110F 1164 11A9;CECA;110F 1164 11A9; # (컊; 컊; 컊; 컊; 컊; ) HANGUL SYLLABLE KYAEGG
CECB;CECB;110F 1164 11AA;CECB;110F 1164 11AA; # (컋; 컋; 컋; 컋; 컋; ) HANGUL SYLLABLE KYAEGS
CECC;CECC;110F 1164 11AB;CECC;110F 1164 11AB; # (컌; 컌; 컌; 컌; 컌; ) HANGUL SYLLABLE KYAEN
CECD;CECD;110F 1164 11AC;CECD;110F 1164 11AC; # (컍; 컍; 컍; 컍; 컍; ) HANGUL SY


_ "github.com/cosmos/cosmos-sdk/client/docs/statik"
)

// Server defines the server's API interface.
type Server struct {
	Router            *mux.Router
	GRPCGatewayRouter *runtime.ServeMux
	ClientCtx         client.Context

	logger  log.Logger
	metrics *telemetry.Metrics
	// Start() is blocking and generally called from a separate goroutine.
	// Close() can be called asynchronously and access shared memory
	// via the listener. Therefore, we sync access to Start and Close with
	// this mutex to avoid data races.
	mtx      sync.Mutex
	listener net.Listener
}

// CustomGRPCHeaderMatcher for mapping request headers to
// GRPC metadata.
// HTTP headers that start with 'Grpc-Metadata-' are automatically mapped to
// gRPC metadata after removing prefix 'Grpc-Metadata-'. We can use this
// CustomGRPCHeaderMatcher if headers don't start with `Grpc-Metadata-`
func CustomGRPCHeaderMatcher(key string) (string, bool) {
	switch strings.ToLower(key) {
	case grpctypes.GRPCBlockHeightHeader:
		return grpctypes.GRPCBlockHeightHeader, true
	default:
		return runtime.DefaultHeaderMatcher(key)
	}
}

func New(clientCtx client.Context, logger log.Logger) *Server {
	// The default JSON marshaller used by the gRPC-Gateway is unable to marshal non-nullable non-scalar fields.
	// Using the gogo/gateway package with the gRPC-Gateway WithMarshaler option fixes the scalar field marshalling issue.
	marshalerOption := &gateway.JSONPb{
		EmitDefaults: true,
		Indent:       "  ",
		OrigName:     true,
		AnyResolver:  clientCtx.InterfaceRegistry,
	}

	return &Server{
		Router:    mux.NewRouter(),
		ClientCtx: clientCtx,
		logger:    logger,
		GRPCGatewayRouter: runtime.NewServeMux(
			// Custom marshaler option is required for gogo proto
			runtime.WithMarshalerOption(runtime.MIMEWildcard, marshalerOption),

			// This is necessary to get error details properly
			// marshalled in unary requests.
			runtime.WithProtoErrorHandler(runtime.DefaultHTTPProtoErrorHandler),

			// Custom header matcher for mapping request headers to
			// GRPC metadata
			runtime.WithIncomingHeaderMatcher(CustomGRPCHeaderMatcher),
		),
	}
}

// Start starts the API server. Internally, the API server leverages Tendermint's
// JSON RPC server. Configuration options are provided via config.APIConfig
// and are delegated to the Tendermint JSON RPC server. The process is
// non-blocking, so an external signal handler must be used.
func (s *Server) Start(cfg config.Config) error {
	s.mtx.Lock()

	tmCfg := tmrpcserver.DefaultConfig()
	tmCfg.MaxOpenConnections = int(cfg.API.MaxOpenConnections)
	tmCfg.ReadTimeout = time.Duration(cfg.API.RPCReadTimeout) * time.Second
	tmCfg.WriteTimeout = time.Duration(cfg.API.RPCWriteTimeout) * time.Second
	tmCfg.MaxBodyBytes = int64(cfg.API.RPCMaxBodyBytes)

	listener, err := tmrpcserver.Listen(cfg.API.Address, tmCfg)
	if err != nil {
		s.mtx.Unlock()
		return err
	}

	s.registerGRPCGatewayRoutes()
	s.listener = listener
	var h http.Handler = s.Router

	s.mtx.Unlock()

	if cfg.API.EnableUnsafeCORS


_trg:
nop
.text
.globl b_dgnthvq_frgPbhagreFrg
.type b_dgnthvq_frgPbhagreFrg,%function
b_dgnthvq_frgPbhagreFrg:
nop
.text
.globl b_pbasvt_serr
.type b_pbasvt_serr,%function
b_pbasvt_serr:
nop
.text
.globl b_ybnq_svyr
.type b_ybnq_svyr,%function
b_ybnq_svyr:
nop
.text
.globl b_angvir_unaqyr_pybfr
.type b_angvir_unaqyr_pybfr,%function
b_angvir_unaqyr_pybfr:
nop
.text
.globl b_guernq_fgber_trg
.type b_guernq_fgber_trg,%function
b_guernq_fgber_trg:
nop
.text
.globl b_naqebvq_erobbg
.type b_naqebvq_erobbg,%function
b_naqebvq_erobbg:
nop
.text
.globl b_sf_zxqvef
.type b_sf_zxqvef,%function
b_sf_zxqvef:
nop
.text
.globl b_unfuzncSerr
.type b_unfuzncSerr,%function
b_unfuzncSerr:
nop
.text
.globl b_fge_cnezf_nqq_sybng
.type b_fge_cnezf_nqq_sybng,%function
b_fge_cnezf_nqq_sybng:
nop
.text
.globl b_fge_cnezf_qhzc
.type b_fge_cnezf_qhzc,%function
b_fge_cnezf_qhzc:
nop
.text
.globl b_ngenpr_frg_genpvat_ranoyrq
.type b_ngenpr_frg_genpvat_ranoyrq,%function
b_ngenpr_frg_genpvat_ranoyrq:
nop
.text
.globl b_pbasvt_ybnq
.type b_pbasvt_ybnq,%function
b_pbasvt_ybnq:
nop
.text
.globl b_pbasvt_frg
.type b_pbasvt_frg,%function
b_pbasvt_frg:
nop
.text
.globl b_fbpxrg_ybpny_freire_ovaq
.type b_fbpxrg_ybpny_freire_ovaq,%function
b_fbpxrg_ybpny_freire_ovaq:
nop
.text
.globl b_fge_cnezf_nqq_vag
.type b_fge_cnezf_nqq_vag,%function
b_fge_cnezf_nqq_vag:
nop
.text
.globl b_nfuzrz_trg_fvmr_ertvba
.type b_nfuzrz_trg_fvmr_ertvba,%function
b_nfuzrz_trg_fvmr_ertvba:
nop
.text
.globl b_xybt_jevgr
.type b_xybt_jevgr,%function
b_xybt_jevgr:
nop
.text
.globl b_ngenpr_vag64_obql
.type b_ngenpr_vag64_obql,%function
b_ngenpr_vag64_obql:
nop
.text
.globl b_fbpxrg_trg_ybpny_cbeg
.type b_fbpxrg_trg_ybpny_cbeg,%function
b_fbpxrg_trg_ybpny_cbeg:
nop
.text
.globl b_cebcregl_yv


og2EstimateRR<float, 3>(x);
    template <typename T, size_t Degree>
    inline T Log2EstimateRR(T x)
    {
        static_assert(
            1 <= Degree && Degree <= 8,
            "Invalid degree.");

        int32_t p{};
        T y = std::frexp(x, &p);  // y in [1/2,1)
        y = static_cast<T>(2) * y;  // y in [1,2)
        --p;
        T poly = Log2Estimate<T, Degree>(y);
        T result = poly + static_cast<T>(p);
        return result;
    }

    template <typename T, size_t Degree>
    T constexpr GetLog2EstimateMaxError()
    {
        static_assert(
            1 <= Degree && Degree <= 8,
            "Invalid degree.");

        return static_cast<T>(C_LOG2_EST_MAX_ERROR[Degree - 1]);
    }
}


es.accessiweb22;

import org.asqatasun.entity.audit.TestSolution;
import org.asqatasun.rules.accessiweb22.test.Aw22RuleImplementationTestCase;

/**
 * Unit test class for the implementation of the rule 3.2.6 of the referential Accessiweb 2.2.
 *
 * @author jkowalczyk
 */
public class Aw22Rule03026Test extends Aw22RuleImplementationTestCase {

    /**
     * Default constructor
     */
    public Aw22Rule03026Test (String testName){
        super(testName);
    }

    @Override
    protected void setUpRuleImplementationClassName() {
        setRuleImplementationClassName(
                "org.asqatasun.rules.accessiweb22.Aw22Rule03026");
    }

    @Override
    protected void setUpWebResourceMap() {
//        getWebResourceMap().put("AW22.Test.3.2.6-1Passed-01",
//              getWebResourceFactory().createPage(
//              getTestcasesFilePath() + "accessiweb22/Aw22Rule03026/AW22.Test.3.2.6-1Passed-01.html"));
//        getWebResourceMap().put("AW22.Test.3.2.6-2Failed-01",
//              getWebResourceFactory().createPage(
//              getTestcasesFilePath() + "accessiweb22/Aw22Rule03026/AW22.Test.3.2.6-2Failed-01.html"));
        getWebResourceMap().put("AW22.Test.3.2.6-3NMI-01",
                getWebResourceFactory().createPage(
                getTestcasesFilePath() + "accessiweb22/Aw22Rule03026/AW22.Test.3.2.6-3NMI-01.html"));
//        getWebResourceMap().put("AW22.Test.3.2.6-4NA-01",
//              getWebResourceFactory().createPage(
//              getTestcasesFilePath() + "accessiweb22/Aw22Rule03026/AW22.Test.3.2.6-4NA-01.html"));
    }

    @Override
    protected void setProcess() {
//        assertEquals(TestSolution.PASSED,
//                processPageTest("AW22.Test.3.2.6-1Passed-01").getValue());
//        assertEquals(TestSolution.FAILED,
//                processPageTest("AW22.Test.3.2.6-2Failed-01").getValue());
        assertEquals(TestSolution.NOT_TESTED,
                processPageTest("AW22.Test.3.2.6-3NMI-01").getValue());
//        assertEquals(TestSolution.NOT_APPLICABLE,
//                processPageTest("AW22.Test.3.2.6-4NA-01").getValue());
    }

    @Override
    protected void setConsolidate() {
//        assertEquals(TestSolution.PASSED,
//                consolidate("AW22.Test.3.2.6-1Passed-01").getValue());
//        assertEquals(TestSolution.FAILED,
//                consolidate("AW22.Test.3.2.6-2Failed-01").getValue());
        assertEquals(TestSolution.NOT_TESTED,
                consolidate("AW22.Test.3.2.6-3NMI-01").getValue());
//        assertEquals(TestSolution.NOT_APPLICABLE,
//                consolidate("AW22.Test.3.2.6-4NA-01").getValue());
    }

}
/*
 * Asqatasun - Automated webpage assessment
 * Copyright (C) 2008-2020  Asqatasun.org
 *
 * This file is part of Asqatasun.
 *
 * Asqatasun 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


            }
            if dups[identifier as usize - 1] {
                return Err(Error::SharingDuplicateIdentifier);
            }
            if s.is_zero() {
                return Err(Error::InvalidShare);
            }
            dups[identifier as usize - 1] = true;

            let y = f(s.value());
            if y.is_none() {
                return Err(Error::InvalidShare);
            }
            x_coordinates[i] = F::from(identifier as u64);
            y_coordinates[i] = y.unwrap();
        }
        let secret = Self::interpolate(&x_coordinates, &y_coordinates);
        Ok(secret)
    }

    pub(crate) fn get_shares_and_polynomial<F, R, const S: usize>(
        secret: F,
        rng: &mut R,
    ) -> ([Share<S>; N], Polynomial<F, T>)
    where
        F: PrimeField,
        R: RngCore + CryptoRng,
    {
        let polynomial = Polynomial::<F, T>::new(secret, rng);
        // Generate the shares of (x, y) coordinates
        // x coordinates are incremental from [1, N+1). 0 is reserved for the secret
        let mut shares: MaybeUninit<[Share<S>; N]> = MaybeUninit::uninit();
        let mut x = F::one();
        for i in 0..N {
            let y = polynomial.evaluate(x);
            let mut t = [0u8; S];
            t[0] = (i + 1) as u8;
            t[1..].copy_from_slice(y.to_repr().as_ref());

            let p = (shares.as_mut_ptr() as *mut Share<S>).wrapping_add(i);
            unsafe { core::ptr::write(p, Share(t)) };

            x += F::one();
        }
        let shares = unsafe { shares.assume_init() };
        (shares, polynomial)
    }

    /// Calculate lagrange interpolation
    fn interpolate<F, S>(x_coordinates: &[F], y_coordinates: &[S]) -> S
    where
        F: PrimeField,
        S: Default + Copy + AddAssign + Mul<F, Output = S>,
    {
        let limit = x_coordinates.len();
        // Initialize to zero
        let mut result = S::default();

        for i in 0..limit {
            let mut basis = F::one();
            for j in 0..limit {
                if i == j {
                    continue;
                }

                let mut denom: F = x_coordinates[j] - x_coordinates[i];
                denom = denom.invert().unwrap();
                // x_m / (x_m - x_j) * ...
                basis *= x_coordinates[j] * denom;
            }

            result += y_coordinates[i] * basis;
        }
        result
    }

    pub(crate) fn check_params<F>(secret: Option<F>) -> Result<(), Error>
    where
        F: PrimeField,
    {
        if N < T {
            return Err(Error::SharingLimitLessThanThreshold);
        }
        if T < 2 {
            return Err(Error::SharingMinThreshold);
        }
        if N > 255 {
            return Err(Error::SharingMaxRequest);
        }
        if secret.is_some() && secret.unwrap().is_zero() {
            return Err(Error::InvalidShare);
        }
        Ok(())
    }
}
use std::{
    fs::File,
    io::{prelude::*, BufReader},
    path::Path,
};

fn parse_input(filename: impl AsRef<Path>) -> Vec<usize> {
    let file = File::open(filename).expect("no such file");
    let mut buf = BufReader


rorf("internal error: %w", err)
		}
		b = buf
	}
	req, err := http.NewRequestWithContext(ctx, method, url, b)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json; charset=utf-8")
	resp, err := c.Client.Do(req)
	// This is a good place to debug if there's an HTTP recording problem.
	return resp, err
}

func (c *ProviderBase[PErrorResponse]) Validate() error {
	if !c.ModelOptional && c.Model == "" {
		return errors.New("a model is required")
	}
	return nil
}

// LastResponseHeaders returns the HTTP headers of the last response.
func (c *ProviderBase[PErrorResponse]) LastResponseHeaders() http.Header {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.lastResp
}

// DoRequest performs an HTTP request and handles error responses.
//
// It takes care of sending the request, decoding the response, and handling errors.
// All API clients should use this method for their HTTP communication needs.
func (c *ProviderBase[PErrorResponse]) DoRequest(ctx context.Context, method, url string, in, out any) error {
	c.lateInit()
	resp, err := c.JSONRequest(ctx, method, url, in)
	if err != nil {
		return err
	}
	return c.DecodeResponse(resp, url, out)
}

func (c *ProviderBase[PErrorResponse]) DecodeResponse(resp *http.Response, url string, out any) error {
	c.mu.Lock()
	c.lastResp = resp.Header
	c.mu.Unlock()
	if resp.StatusCode != 200 {
		return c.DecodeError(url, resp)
	}
	b, err := io.ReadAll(resp.Body)
	if err2 := resp.Body.Close(); err == nil {
		err = err2
	}
	if err != nil {
		return err
	}
	// It's an HTTP 200, it generally should be a success.
	r := bytes.NewReader(b)
	var r2 io.ReadSeeker
	d := json.NewDecoder(r)
	if !c.Lenient {
		d.DisallowUnknownFields()
		r2 = r
	}
	var errs []error
	foundExtraKeys, errJSON := internal.DecodeJSON(d, out, r2)
	if errJSON == nil {
		// It may have succeeded but not decoded anything.
		if v := reflect.ValueOf(out); !reflect.DeepEqual(out, reflect.Zero(v.Type()).Interface()) {
			return nil
		}
	} else if foundExtraKeys {
		errs = append(errs, errJSON)
	}
	if _, err = r.Seek(0, 0); err != nil {
		return err
	}
	d = json.NewDecoder(r)
	if !c.Lenient {
		d.DisallowUnknownFields()
		r2 = r
	}
	er := reflect.New(c.errorResponse).Interface().(PErrorResponse)
	if foundExtraKeys, err := internal.DecodeJSON(d, er, r2); err == nil {
		// It may have succeeded but not decoded anything.
		if v := reflect.ValueOf(er); !reflect.DeepEqual(v, reflect.Zero(c.errorResponse).Interface()) {
			errs = append(errs, er)
		}
	} else if foundExtraKeys {
		// This is confusing, not sure it's a good idea. The problem is that we need to detect when error fields
		// appear too!
		if len(errs) == 0 {
			errs = append(errs, errJSON)
		}
	} else {
		// Return only the original error.
		return err
	}
	return errors.Join(errs...)
}

// DecodeError handles HTTP error responses from API calls.
//
// It handles JSON decoding of error responses and provides appropriate error messages
// with context such as API key URLs for unauthorized errors.
func (c *ProviderBase[PErrorResponse]) DecodeError(url string, resp *http.Response) error {
	c.mu.Lock()
	c.lastResp = resp.Header
	c.mu.Unlock()
	c.lateInit()
	// When we are in lenient mode, we do not want to buffer the


LjQgMTQuNCwxOCAxMCwxOCBMMTAsMTggWiIgaWQ9IlNoYXBlIi8+PC9nPjwvZz48L2c+PC9zdmc+')
     }
     .md-typeset .admonition.video,
     .md-typeset details.video {
    font-size: 1.0em !important;
    border-color: #85001d0c;
     }
     .md-typeset .video > .admonition-title,
     .md-typeset .video > summary {
    background-color: #ffe9ee;
     }
     .md-typeset .video > .admonition-title::before,
     .md-typeset .video > summary::before {
    background-color: #da002ffb;
    -webkit-mask-image: var(--md-admonition-icon--video);
         mask-image: var(--md-admonition-icon--video);
     }
     /* Audio */
   :root {
    --md-admonition-icon--audio: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiA/Pjxzdmcgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMjQgMjQ7IiB2ZXJzaW9uPSIxLjEiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayI+PHN0eWxlIHR5cGU9InRleHQvY3NzIj4KCS5zdDB7b3BhY2l0eTowLjI7ZmlsbDpub25lO3N0cm9rZTojMDAwMDAwO3N0cm9rZS13aWR0aDo1LjAwMDAwMGUtMDI7c3Ryb2tlLW1pdGVybGltaXQ6MTA7fQo8L3N0eWxlPjxnIGlkPSJMYXllcl8xIi8+PGcgaWQ9IkxheWVyXzIiPjxwYXRoIGQ9Ik0xMiwzYy01LDAtOSw0LTksOXY0YzAsMC42LDAuNCwxLDEsMXYxYzAsMS43LDEuMywzLDMsM2gxYzAuNiwwLDEtMC40LDEtMXYtN2MwLTAuNi0wLjQtMS0xLTFIN2MtMC44LDAtMS41LDAuMy0yLDAuOFYxMiAgIGMwLTMuOSwzLjEtNyw3LTdzNywzLjEsNyw3djAuOGMtMC41LTAuNS0xLjItMC44LTItMC44aC0xYy0wLjYsMC0xLDAuNC0xLDF2N2MwLDAuNiwwLjQsMSwxLDFoMWMxLjcsMCwzLTEuMywzLTN2LTEgICBjMC42LDAsMS0wLjQsMS0xdi00QzIxLDcsMTcsMywxMiwzeiBNNiwxNWMwLTAuNiwwLjQtMSwxLTF2NWMtMC42LDAtMS0wLjQtMS0xVjE1eiBNMTgsMThjMCwwLjYtMC40LDEtMSwxdi01YzAuNiwwLDEsMC40LDEsMVYxOHogICAiLz48L2c+PC9zdmc+')
     }
     .md-typeset .admonition.audio,
     .md-typeset details.audio {
    font-size: 1


            stringify!(Sbz1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_ACL>())).AclSize as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(_ACL),
            "::",
            stringify!(AclSize)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_ACL>())).AceCount as *const _ as usize },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(_ACL),
            "::",
            stringify!(AceCount)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_ACL>())).Sbz2 as *const _ as usize },
        6usize,
        concat!(
            "Offset of field: ",
            stringify!(_ACL),
            "::",
            stringify!(Sbz2)
        )
    );
}
pub type ACL = _ACL;
pub type PACL = *mut _ACL;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _SECURITY_DESCRIPTOR {
    pub Revision: UCHAR,
    pub Sbz1: UCHAR,
    pub Control: SECURITY_DESCRIPTOR_CONTROL,
    pub Owner: PSID,
    pub Group: PSID,
    pub Sacl: PACL,
    pub Dacl: PACL,
}
#[test]
fn bindgen_test_layout__SECURITY_DESCRIPTOR() {
    assert_eq!(
        ::std::mem::size_of::<_SECURITY_DESCRIPTOR>(),
        40usize,
        concat!("Size of: ", stringify!(_SECURITY_DESCRIPTOR))
    );
    assert_eq!(
        ::std::mem::align_of::<_SECURITY_DESCRIPTOR>(),
        8usize,
        concat!("Alignment of ", stringify!(_SECURITY_DESCRIPTOR))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_SECURITY_DESCRIPTOR>())).Revision as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_SECURITY_DESCRIPTOR),
            "::",
            stringify!(Revision)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_SECURITY_DESCRIPTOR>())).Sbz1 as *const _ as usize },
        1usize,
        concat!(
            "Offset of field: ",
            stringify!(_SECURITY_DESCRIPTOR),
            "::",
            stringify!(Sbz1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_SECURITY_DESCRIPTOR>())).Control as *const _ as usize },
        2usize,
        concat!(
            "Offset of field: ",
            stringify!(_SECURITY_DESCRIPTOR),
            "::",
            stringify!(Control)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_SECURITY_DESCRIPTOR>())).Owner as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_SECURITY_DESCRIPTOR),
            "::",
            stringify!(Owner)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_SECURITY_DESCRIPTOR>())).Group as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_SECURITY_DESCRIPTOR),
            "::",
            stringify!(Group)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_SECURITY_DESCRIPTOR>())).Sacl as


d)
            bindOnClickEvent(context, remoteViews)

        val originalTodaySchedule: String = widgetData.getString("todaySchedule", null) ?: "{'value':[]}"
        val todaySchedule: List<List<String>> = Json.decodeFromString<CustomData>(originalTodaySchedule).value
        if (todaySchedule.isNotEmpty()) {
            Log.d(TAG, "updateContent: todaySchedule:")
            setData(remoteViews, todaySchedule, isSmall, true)
        } else {
            val originalTomorrowSchedule: String = widgetData.getString("tomorrowSchedule", null) ?: "{'value':[]}"
            val tomorrowSchedule: List<List<String>> = Json.decodeFromString<CustomData>(originalTomorrowSchedule).value
            if (tomorrowSchedule.isNotEmpty()) {
                Log.d(TAG, "updateContent: tomorrowSchedule")
                setData(remoteViews, tomorrowSchedule, isSmall, false)
            } else {
                nullValueTemplate(remoteViews)
            }
        }

        val message: String? = widgetData.getString("message", "")

        if (!message.isNullOrEmpty()) {
            remoteViews.setTextViewText(R.id.widget_message, message)
        }

        remoteViews.setTextViewText(R.id.widget_title, widgetData.getString("title", null))
        remoteViews.setViewVisibility(R.id.loading_text, View.GONE)
        remoteViews.setViewVisibility(R.id.widget_container, View.VISIBLE)
        remoteViews.setViewVisibility(R.id.refresh_icon, View.VISIBLE)
    }

    @RequiresApi(Build.VERSION_CODES.S)
    override fun onUpdate(context: Context, appWidgetManager: AppWidgetManager, appWidgetIds: IntArray, widgetData: SharedPreferences) {
        Log.d(TAG, "HomeWidgetExampleProvider.onUpdate")
        appWidgetIds.forEach { widgetId ->
            print("widgetId:")
            println(widgetId)
            val smallViews = RemoteViews(context.packageName, R.layout.widget_small).apply {
                updateContent(context, widgetData, this, true)
            }
            val mediumViews = RemoteViews(context.packageName, R.layout.widget_medium).apply {
                updateContent(context, widgetData, this, false)
            }
            appWidgetManager.updateAppWidget(
                widgetId, RemoteViews(
                    mapOf(
                        SizeF(180.0f, 110.0f) to smallViews,
                        SizeF(270.0f, 110.0f) to mediumViews
                    )
                )
            )
            toastCount = 0
            isInitialized = true
        }
    }
}
package com.napzak.market.onboarding.termsAgreement

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.asPaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.navigationBars
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.res.vectorResource
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx


68.25,0,0,0-4,20.08c-.06,1.2,0,2.58.9,3.37-4.45-3.61-10.74-3.5-16.46-3.24a4.1,4.1,0,0,1-1.6-.13,3.58,3.58,0,0,1-1.41-1.16,14,14,0,0,1-3-6.72c-.54-3.53.28-7.11,1-10.61a54.67,54.67,0,0,0,1.3-10.27c.05-3.52-1.06-6.36-1.64-9.71-.71-4.05,3.81-2.06,6.23-1.59Z"
        transform="translate(-93.21 -65.12)"
        fill="currentColor" />
</svg>
<!doctype html>
<html>
<head>
	<meta charset="utf-8">
	<script src="../bower_components/webcomponentsjs/webcomponents.js"></script>
	<script src="../bower_components/web-component-tester/browser.js"></script>
	<script src="TestHelper.js"></script>
	<script>
		var should = chai.should();
	</script>
	<link rel="import" href="../build/strand.html">
</head>
<body>

	<strand-list-item id="default">Magic</strand-list-item>

	<div id="resize" style="width:500px;">
		<strand-list-item id="resizee">Some longer text string should appear here.</strand-list-item>
	</div>

	<script type="text/javascript">

		describe("strand-list-item", function() {

			it("should have an element constructor", function() {
				var a = new Strand.ListItem();
				a.nodeName.should.equal("STRAND-LIST-ITEM");
			});

			it("should set title attribute when it's container's width is changed", function(done) {
				var a = document.querySelector("#resizee"),
					r = document.querySelector("#resize"),
					title = null;

				r.style.width = "150px";

				setTimeout(function(){
					title = a.getAttribute("title");
					done();
				}, 150);
			});

		});

	</script>

</body>
</html><!DOCTYPE html>
<html>
	<head>
		<script src="../../bower_components/webcomponentsjs/webcomponents.min.js"></script>
		<link rel="import" href="../../strand.html"/>
		<script src="//cdnjs.cloudflare.com/ajax/libs/ace/1.1.3/ace.js"></script>
		<script src="//cdnjs.cloudflare.com/ajax/libs/jquery/1.11.1/jquery.js"></script>
		<script src="//cdnjs.cloudflare.com/ajax/libs/underscore.js/1.6.0/underscore-min.


ng a data block's
	 * journaling status dynamically is dangerous.  If we write a
	 * data block to the journal, change the status and then delete
	 * that block, we risk forgetting to revoke the old log record
	 * from the journal and so a subsequent replay can corrupt data.
	 * So, first we make sure that the journal is empty and that
	 * nobody is changing anything.
	 */

	journal = EXT3_JOURNAL(inode);
	if (is_journal_aborted(journal) || IS_RDONLY(inode))
		return -EROFS;

	journal_lock_updates(journal);
	journal_flush(journal);

	/*
	 * OK, there are no updates running now, and all cached data is
	 * synced to disk.  We are now in a completely consistent state
	 * which doesn't have anything in the journal, and we know that
	 * no filesystem updates are running, so it is safe to modify
	 * the inode's in-core data-journaling state flag now.
	 */

	if (val)
		EXT3_I(inode)->i_flags |= EXT3_JOURNAL_DATA_FL;
	else
		EXT3_I(inode)->i_flags &= ~EXT3_JOURNAL_DATA_FL;
	ext3_set_aops(inode);

	journal_unlock_updates(journal);

	/* Finally we can mark the inode as dirty. */

	handle = ext3_journal_start(inode, 1);
	if (IS_ERR(handle))
		return PTR_ERR(handle);

	err = ext3_mark_inode_dirty(handle, inode);
	handle->h_sync = 1;
	ext3_journal_stop(handle);
	ext3_std_error(inode->i_sb, err);

	return err;
}


XIT
ERREUR3:
	PRINT	ERROR3(PC)
;	GETKEY
	EXIT

ERROR1:	DC.B	'FILE NOT FOUND...',13,10,0
ERROR2:	DC.B	'ERROR DURING WRITING',13,10,0
ERROR3:	DC.B	'FILE TOO BIG',13,10,0
FINAL:
	DC.B	'TOTAL SECTORS= '
NBSEC:	DC.B	'    , LAST TRACK= '
PTRACK:	DC.B	'  , LAST SECTOR= '
PSECTOR:DC.B	'  ',13,10,0
MESS1:	DC.B	'INSERT DISK IN DRIVE '
	DC.B	'A'+DISK,0
MESS2:	DC.B	'SAVING FILE ',0
MESS3:	DC.B	'LOADING FILE ',0
CR:	DC.B	13,10,0
	EVEN
TAMPON:


 code is governed by a BSD-style
// license that can be found in the LICENSE file.

package relayd

import (
	"testing"

	"github.com/33cn/chain33/common"
	"github.com/33cn/chain33/common/address"
	"github.com/33cn/chain33/common/crypto"
	"github.com/33cn/chain33/types"
	typesmocks "github.com/33cn/chain33/types/mocks"
	types2 "github.com/33cn/plugin/plugin/dapp/relay/types"
	"github.com/stretchr/testify/mock"
)

func TestGeneratePrivateKey(t *testing.T) {
	cr, err := crypto.Load(types.GetSignName("", types.SECP256K1), -1)
	if err != nil {
		t.Fatal(err)
	}

	key, err := cr.GenKey()
	if err != nil {
		t.Fatal(err)
	}

	t.Log("private key: ", common.ToHex(key.Bytes()))
	t.Log("publick key: ", common.ToHex(key.PubKey().Bytes()))
	t.Log("    address: ", address.PubKeyToAddr(address.DefaultID, key.PubKey().Bytes()))
}

func TestDealOrder(t *testing.T) {
	grpcClient := &typesmocks.Chain33Client{}
	relayd := &Relayd{}
	relayd.client33 = &Client33{}
	relayd.client33.Chain33Client = grpcClient
	relayd.btcClient = &btcdClient{
		connConfig:          nil,
		chainParams:         mainNetParams.Params,
		reconnectAttempts:   3,
		enqueueNotification: make(chan interface{}),
		dequeueNotification: make(chan interface{}),
		currentBlock:        make(chan *blockStamp),
		quit:                make(chan struct{}),
	}

	relayorder := &types2.RelayOrder{Id: string("id"), XTxHash: "hash"}
	rst := &types2.QueryRelayOrderResult{Orders: []*types2.RelayOrder{relayorder}}
	reply := &types.Reply{}
	reply.Msg = types.Encode(rst)
	grpcClient.On("QueryChain", mock.Anything, mock.Anything).Return(reply, nil).Once()
	grpcClient.On("SendTransaction", mock.Anything, mock.Anything).Return(nil, nil).Once()
	relayd.dealOrder()
}
// Copyright Fuzamei Corp. 2018 All Rights Reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package autotest

import (
	"github.com/33cn/chain33/cmd/autotest/types"

	"strconv"
)

// TokenPreCreateCase token precreatecase command
type TokenPreCreateCase struct {
	types.BaseCase
	//From string `toml:"from"`
	//Amount string `toml:"amount"`
}

// TokenPreCreatePack defines token precreate package command
type TokenPreCreatePack struct {
	types.BaseCasePack
}

// TokenFinishCreateCase token finish create case command
type TokenFinishCreateCase struct {
	types.BaseCase
	//From string `toml:"from"`
	//Amount string `toml:"amount"`
}

// TokenFinishCreatePack token finish create pack command
type TokenFinishCreatePack struct {
	types.BaseCasePack
}

// TokenRevokeCase token revoke case command
type TokenRevokeCase struct {
	types.BaseCase
}

// TokenRevokePack token revoke pack command
type TokenRevokePack struct {
	types.BaseCasePack
}

// SendCommand defines send command function of tokenprecreatecase
func (testCase *TokenPreCreateCase) SendCommand(packID string) (types.PackFunc, error) {

	return types.DefaultSend(testCase, &TokenPreCreatePack{}, packID)
}

// SendCommand defines send command function of tokenrevokecase
func (testCase *TokenRevokeCase) SendCommand(packID string) (types.PackFunc, error) {

	r


def _cat_labels(self, mosaic_labels):
    """Return labels with mosaic border instances clipped."""
    if len(mosaic_labels) == 0:
        return {}
    cls = []
    instances = []
    imgsz = self.imgsz * 2
    for labels in mosaic_labels:
        cls.append(labels['cls'])
        instances.append(labels['instances'])
    final_labels = {'im_file': mosaic_labels[0]['im_file'], 'ori_shape':
        mosaic_labels[0]['ori_shape'], 'resized_shape': (imgsz, imgsz),
        'cls': np.concatenate(cls, 0), 'instances': Instances.concatenate(
        instances, axis=0), 'mosaic_border': self.border}
    final_labels['instances'].clip(imgsz, imgsz)
    good = final_labels['instances'].remove_zero_area_boxes()
    final_labels['cls'] = final_labels['cls'][good]
    return final_labels


    instance
        .get_typed_func::<(Rc<u32>,), (), _>(&mut store, "take-u32")?
        .call(&mut store, (Rc::new(2),))?;
    instance
        .get_typed_func::<(Arc<u32>,), (), _>(&mut store, "take-u32")?
        .call(&mut store, (Arc::new(2),))?;
    instance
        .get_typed_func::<(&Box<Arc<Rc<u32>>>,), (), _>(&mut store, "take-u32")?
        .call(&mut store, (&Box::new(Arc::new(Rc::new(2))),))?;

    Ok(())
}

#[test]
fn floats() -> Result<()> {
    let component = r#"
        (component
            (core module $m
                (func (export "i32.reinterpret_f32") (param f32) (result i32)
                    local.get 0
                    i32.reinterpret_f32
                )
                (func (export "i64.reinterpret_f64") (param f64) (result i64)
                    local.get 0
                    i64.reinterpret_f64
                )
                (func (export "f32.reinterpret_i32") (param i32) (result f32)
                    local.get 0
                    f32.reinterpret_i32
                )
                (func (export "f64.reinterpret_i64") (param i64) (result f64)
                    local.get 0
                    f64.reinterpret_i64
                )
            )
            (core instance $i (instantiate $m))

            (func (export "f32-to-u32") (param float32) (result u32)
                (canon lift (core func $i "i32.reinterpret_f32"))
            )
            (func (export "f64-to-u64") (param float64) (result u64)
                (canon lift (core func $i "i64.reinterpret_f64"))
            )
            (func (export "u32-to-f32") (param u32) (result float32)
                (canon lift (core func $i "f32.reinterpret_i32"))
            )
            (func (export "u64-to-f64") (param u64) (result float64)
                (canon lift (core func $i "f64.reinterpret_i64"))
            )
        )
    "#;

    let engine = super::engine();
    let component = Component::new(&engine, component)?;
    let mut store = Store::new(&engine, ());
    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
    let f32_to_u32 = instance.get_typed_func::<(f32,), u32, _>(&mut store, "f32-to-u32")?;
    let f64_to_u64 = instance.get_typed_func::<(f64,), u64, _>(&mut store, "f64-to-u64")?;
    let u32_to_f32 = instance.get_typed_func::<(u32,), f32, _>(&mut store, "u32-to-f32")?;
    let u64_to_f64 = instance.get_typed_func::<(u64,), f64, _>(&mut store, "u64-to-f64")?;

    assert_eq!(f32_to_u32.call(&mut store, (1.0,))?, 1.0f32.to_bits());
    assert_eq!(f64_to_u64.call(&mut store, (2.0,))?, 2.0f64.to_bits());
    assert_eq!(u32_to_f32.call(&mut store, (3.0f32.to_bits(),))?, 3.0);
    assert_eq!(u64_to_f64.call(&mut store, (4.0f64.to_bits(),))?, 4.0);

    assert_eq!(
        u32_to_f32
            .call(&mut store, (CANON_32BIT_NAN


GreaterOrEqualSeven"])
		assert.Equal(t, 36, m["vulnerabilities"])

		assert.Equal(t, 36, len(vulns))
	})
}

func TestLoadExistingProductSuccess(t *testing.T) {

	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {

		response := ProductData{
			Products: []Product{
				{ProductID: 1, FileName: "file_1.zip"},
			},
		}

		var b bytes.Buffer
		json.NewEncoder(&b).Encode(&response)
		rw.Write([]byte(b.Bytes()))
	}))
	// Close the server when test finishes
	defer server.Close()

	cases := []struct {
		pc             Protecode
		protecodeGroup string
		fileName       string
		want           int
	}{
		{makeProtecode(Options{ServerURL: server.URL}), "group", "file_1.zip", 1},
	}
	for _, c := range cases {

		got := c.pc.LoadExistingProduct(c.protecodeGroup, c.fileName)
		assert.Equal(t, c.want, got)
	}
}

func TestPollForResultSuccess(t *testing.T) {
	requestURI := ""
	var response ResultData = ResultData{}

	protecodePollInterval = time.Nanosecond

	server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
		requestURI = req.RequestURI
		productID := 111

		// 2021-04-20 d :
		// Added case '333' to test proper handling of case where Component list is empty.
		if strings.Contains(requestURI, "222") {
			productID = 222
		} else if strings.Contains(requestURI, "333") {
			productID = 333
		}

		var cmpnts []Component
		if productID != 333 {
			cmpnts = []Component{
				{Vulns: []Vulnerability{
					{Triage: []Triage{{ID: 1}}}},
				}}
		}

		response = ResultData{Result: Result{ProductID: productID, ReportURL: requestURI, Status: "D", Components: cmpnts}}

		var b bytes.Buffer
		json.NewEncoder(&b).Encode(&response)
		rw.Write([]byte(b.Bytes()))

	}))

	cases := []struct {
		productID int
		want      ResultData
	}{
		{111, ResultData{Result: Result{ProductID: 111, ReportURL: "/api/product/111/", Status: "D", Components: []Component{
			{Vulns: []Vulnerability{
				{Triage: []Triage{{ID: 1}}}},
			}},
		}}},
		{222, ResultData{Result: Result{ProductID: 222, ReportURL: "/api/product/222/", Status: "D", Components: []Component{
			{Vulns: []Vulnerability{
				{Triage: []Triage{{ID: 1}}}},
			}},
		}}},
		{333, ResultData{Result: Result{ProductID: 333, ReportURL: "/api/product/333/", Status: "D"}}},
	}
	// Close the server when test finishes
	defer server.Close()

	pc := makeProtecode(Options{ServerURL: server.URL, Duration: (time.Minute * 1)})

	for _, c := range cases {
		got := pc.PollForResult(c.productID, "1")
		assert.Equal(t, c.want, got)
		assert.Equal(t, fmt.Sprintf("/api/product/%v/", c.productID), requestURI)
	}
}

func TestPullResultSuccess(t *testing.T) {

	requestURI := ""

	server := httptest.NewServer(http.HandlerFunc(func(rw http.Response


ators: `AND`, `OR`, `NOT`)
* **Fields (`field=value`):** Filter by specific values in fields extracted by `Splunk`.
    * `src_ip="192.168.1.10"`
    * `user="admin"`
    * `status_code=404`
    * `EventCode=4625` (Comparators can be used: `>`, `<`, `>=`, `<=`, `!=`)
* **Pipe (`|`): Essential.** Sends the results of an initial search to subsequent commands for processing (filter, transform, aggregate, format). `command1 | command2 | command3 ...`

---

⌨ Essential SPL Commands (Cheatsheet Table)

> Here is a table with common and useful SPL commands for security analysis:

| SPL Command (Example)                       | Description                                                                                |
| :------------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------- |
| `search <terms>` (implied)                  | Base command. Searches for matching events. Ex: `index="security" host="dc01" EventCode=4625`                                                      |
| **Filtering/Selection:** |                                                                                |
| `head [N]`                                  | Shows the **first N** events (default 10) based on the current order (usually reverse chronological). Ex: `... \| head 20`                        |
| `tail [N]`                                  | Shows the **last N** events based on the current order.                                                                                |
| `where <condition>`                         | Filters results **after** the initial search, using comparisons (`>`, `<`, `!=`, etc.), functions (`like()`, `cidrmatch()`). Ex: `... \| where process_name like "%.exe"` |
| **Grouping/Statistics:** |                                                                                |
| `stats <func(field)> BY <group_field>`      | **Very powerful.** Performs statistical calculations. Functions: `count`, `dc` (distinct_count), `avg`, `sum`, `min`, `max`, `values`, `list`. Groups with `BY`. |
|  _*Ex: `... \| stats count BY src_ip`*_     | _*Counts events by source IP.*_                                                                                |
|  _*Ex: `... \| stats dc(user) BY host`*_    | _*Counts unique users per host.*_                                                                                |
|  _*Ex: `... \| stats values(action) AS Actions BY user`*_ | _*Lists unique actions per user (renaming the field to 'Actions').*_                                                               |
| `top <field> [limit=N]`                     | Shows the N most frequent values of a field, with their count and percentage. Ex: `index=fw "action=blocked" \| top src_ip limit=10`               |
| `rare <field> [limit=N]`                    | Shows the N least frequent values of a field. Useful for finding anomalies. Ex: `... \| rare user_agent limit=10`                              |
| **Formatting/Display:** |                                                                                |
| `table <field1> <field2> ...`               | Displays results in a table, **only** with the specified fields. Ex: `... \| table _time, user, src_ip, dest_ip, status`                         |
| `fields [+]/- <field1> ...`                 | **Adds (`+`) or removes (`-`)** fields from the results view without hiding others. Ex: `... \| fields - _raw, host`                             |
| `rename <original_field> AS <new_field>`


 для печати только одного номера газеты. То есть для печати сегодняшних новостей необходим один печатный станок, для завтрашних, другой и т.д. Подобный станок сравним с _обычным типом_ признаки которого после объявления остаются неизменны при его реализации. Другими словами, если при существовании типа `A`, описание которого включает поле, принадлежащее к типу `number`, потребуется тип, отличие которого будет состоять лишь в принадлежности поля к другому типу, возникнет необходимость в его объявлении.

`````ts
// простые типы сравнимы с монолитами

// этот станок предназначен для печати газет под номером A
interface A {
    field: number;
}

// этот станок предназначен для печати газет под номером B
interface B {
    field: string;
}

// и т.д.
`````

К счастью, в нашей реальности нашли решение не только относительно печатных станков, но и типов. Нежелания тратить усилия на постоянное описывание монолитных типов послужило причиной зарождения парадигмы _обобщенного программирования_.

_Обобщенное программирование_ (_Generic Programming_) — это подход, при котором алгоритмы могут одинаково работать с данными, принадлежащими к разным типам данных без изменения декларации (описания типа).

В основе обобщенного программирования лежит такое ключевое понятие как _обобщение_. _Обобщение_ (_Generics_) — это _параметризированный тип_ позволяющий объявлять _параметры типа_, являющиеся временной заменой _конкретных типов_, _конкретизация_ которых будет выполнена в момент создания экземпляра. Параметры типа, при условии соблюдения некоторых правил, можно использовать в большинстве операций, допускающих работу с обычными типами. Все это вместе дает повод сравнивать обобщенный тип с _правильной версией_ печатного станка, чьи заменяемые валы, предназначенные для отпечатывания информации на проходящей через них бумаге, сопоставимы с _параметрами типа_.

В реальности обобщения позволяют сокращать количество преобразований (приведений) и писать многократно используемый код, при этом повышая его типобезопасность.

Этих примеров должно быть достаточно


etExec
	}
	return ""
}

func (x *ReplyUnfreeze) GetAssetSymbol() string {
	if x != nil {
		return x.AssetSymbol
	}
	return ""
}

func (x *ReplyUnfreeze) GetTotalCount() int64 {
	if x != nil {
		return x.TotalCount
	}
	return 0
}

func (x *ReplyUnfreeze) GetInitiator() string {
	if x != nil {
		return x.Initiator
	}
	return ""
}

func (x *ReplyUnfreeze) GetBeneficiary() string {
	if x != nil {
		return x.Beneficiary
	}
	return ""
}

func (x *ReplyUnfreeze) GetRemaining() int64 {
	if x != nil {
		return x.Remaining
	}
	return 0
}

func (x *ReplyUnfreeze) GetMeans() string {
	if x != nil {
		return x.Means
	}
	return ""
}

func (m *ReplyUnfreeze) GetMeansOpt() isReplyUnfreeze_MeansOpt {
	if m != nil {
		return m.MeansOpt
	}
	return nil
}

func (x *ReplyUnfreeze) GetFixAmount() *FixAmount {
	if x, ok := x.GetMeansOpt().(*ReplyUnfreeze_FixAmount); ok {
		return x.FixAmount
	}
	return nil
}

func (x *ReplyUnfreeze) GetLeftProportion() *LeftProportion {
	if x, ok := x.GetMeansOpt().(*ReplyUnfreeze_LeftProportion); ok {
		return x.LeftProportion
	}
	return nil
}

func (x *ReplyUnfreeze) GetTerminated() bool {
	if x != nil {
		return x.Terminated
	}
	return false
}

func (x *ReplyUnfreeze) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

type isReplyUnfreeze_MeansOpt interface {
	isReplyUnfreeze_MeansOpt()
}

type ReplyUnfreeze_FixAmount struct {
	FixAmount *FixAmount `protobuf:"bytes,10,opt,name=fixAmount,proto3,oneof"`
}

type ReplyUnfreeze_LeftProportion struct {
	LeftProportion *LeftProportion `protobuf:"bytes,11,opt,name=leftProportion,proto3,oneof"`
}

func (*ReplyUnfreeze_FixAmount) isReplyUnfreeze_MeansOpt() {}

func (*ReplyUnfreeze_LeftProportion) isReplyUnfreeze_MeansOpt() {}

type ReplyUnfreezes struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Unfreeze []*ReplyUnfreeze `protobuf:"bytes,1,rep,name=unfreeze,proto3" json:"unfreeze,omitempty"`
}

func (x *ReplyUnfreezes) Reset() {
	*x = ReplyUnfreezes{}
	if protoimpl.UnsafeEnabled {
		mi := &file_unfreeze_proto_msgTypes[12]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *ReplyUnfreezes) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ReplyUnfreezes) ProtoMessage() {}

func (x *ReplyUnfreezes) ProtoReflect() protoreflect.Message {
	mi := &file_unfreeze_proto_msgTypes[12]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ReplyUnfree


      loss_total_dict['epochs'] = epoch
                loss_total_dict['losses_val'].append(running_loss_val/log_interval_val)
                loss_total_dict['accuracies_val'].append(running_acc_val/log_interval_val)

                if running_loss/log_interval <= loss_total_dict['best_loss_val']:
                    loss_total_dict['best_loss_val'] = running_loss_val/log_interval_val
                    torch.save(model.state_dict(), join(model_save_path_new, "best_val") + '.th')

                if epoch in checkpoints:
                    with open(join(model_save_path_new, str(model_number))+"-train", 'wb') as filezin:
                        pickle.dump(loss_total_dict, filezin)

                running_loss_val = 0.0
                running_acc_val = 0.0

        print("\n")

train_cycle()


t
*
* 	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.
*/

using System;

namespace OpenSearch.Net.Extensions
{
	internal static class Fluent
	{
		internal static TDescriptor Assign<TDescriptor, TInterface, TValue>(TDescriptor self, TValue value, Action<TInterface, TValue> assign)
			where TDescriptor : class, TInterface
		{
			assign(self, value);
			return self;
		}
	}
}


import org.jspecify.annotations.*;

import java.nio.*;

import org.lwjgl.*;

import org.lwjgl.system.*;

import static org.lwjgl.system.Checks.*;
import static org.lwjgl.system.JNI.*;
import static org.lwjgl.system.MemoryUtil.*;

public class METAEnvironmentDepth {

    public static final int XR_META_environment_depth_SPEC_VERSION = 1;

    public static final String XR_META_ENVIRONMENT_DEPTH_EXTENSION_NAME = "XR_META_environment_depth";

    public static final int
        XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_PROVIDER_META  = 1000291000,
        XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_META = 1000291001;

    public static final int
        XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META  = 1000291000,
        XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META = 1000291001,
        XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META       = 1000291002,
        XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META    = 1000291003,
        XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META            = 1000291004,
        XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META                 = 1000291005,
        XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META = 1000291006,
        XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META     = 1000291007;

    public static final int XR_ENVIRONMENT_DEPTH_NOT_AVAILABLE_META = 1000291000;

    protected METAEnvironmentDepth() {
        throw new UnsupportedOperationException();
    }

    // --- [ xrCreateEnvironmentDepthProviderMETA ] ---

    /** {@code XrResult xrCreateEnvironmentDepthProviderMETA(XrSession session, XrEnvironmentDepthProviderCreateInfoMETA const * createInfo, XrEnvironmentDepthProviderMETA * environmentDepthProvider)} */
    public static int nxrCreateEnvironmentDepthProviderMETA(XrSession session, long createInfo, long environmentDepthProvider) {
        long __functionAddress = session.getCapabilities().xrCreateEnvironmentDepthProviderMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPPPI(session.address(), createInfo, environmentDepthProvider, __functionAddress);
    }

    /** {@code XrResult xrCreateEnvironmentDepthProviderMETA(XrSession session, XrEnvironmentDepthProviderCreateInfoMETA const * createInfo, XrEnvironmentDepthProviderMETA * environmentDepthProvider)} */
    @NativeType("XrResult")
    public static int xrCreateEnvironmentDepthProviderMETA(XrSession session, @NativeType("XrEnvironmentDepthProviderCreateInfoMETA const *") XrEnvironmentDepthProviderCreateInfoMETA createInfo, @NativeType("XrEnvironmentDepthProviderMETA *") PointerBuffer environmentDepthProvider) {
        if (CHECKS) {
            check(environmentDepthProvider, 1);
        }
        return nxrCreateEnvironmentDepthProviderMETA(session, createInfo.address(), memAddress(environmentDepthProvider));
    }

    // --- [ xrDestroyEnvironmentDepthProviderMETA ] ---

    /** {@code XrResult xrDestroyEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider)} */
    @NativeType("XrResult")
    public static int xrDestroyEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider) {
        long __functionAddress = environmentDepthProvider.getCapabilities().xrDestroyEnvironmentDepthProviderMETA;
        if (CHECKS) {
            check(__functionAddress);
        }
        return callPI(environmentDepthProvider.address(), __functionAddress);
    }

    // --- [ xrStartEnvironmentDepthProviderMETA ] ---

    /** {@code XrResult xrStartEnvironmentDepthProviderMETA(XrEnvironmentDepthProviderMETA environmentDepthProvider)} */
    @NativeType("XrResult")
    public static int xrStartEnvironmentDepthProviderMETA(XrEnvironmentDepthProvi


.DecStructFieldNotFound(yyj283-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *PersistentVolumeSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym289 := z.EncBinary()
		_ = yym289
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep290 := !z.EncBinary()
			yy2arr290 := z.EncBasicHandle().StructToArray
			var yyq290 [16]bool
			_, _, _ = yysep290, yyq290, yy2arr290
			const yyr290 bool = false
			yyq290[0] = len(x.Capacity) != 0
			yyq290[1] = x.PersistentVolumeSource.GCEPersistentDisk != nil && x.GCEPersistentDisk != nil
			yyq290[2] = x.PersistentVolumeSource.AWSElasticBlockStore != nil && x.AWSElasticBlockStore != nil
			yyq290[3] = x.PersistentVolumeSource.HostPath != nil && x.HostPath != nil
			yyq290[4] = x.PersistentVolumeSource.Glusterfs != nil && x.Glusterfs != nil
			yyq290[5] = x.PersistentVolumeSource.NFS != nil && x.NFS != nil
			yyq290[6] = x.PersistentVolumeSource.RBD != nil && x.RBD != nil
			yyq290[7] = x.PersistentVolumeSource.ISCSI != nil && x.ISCSI != nil
			yyq290[8] = x.PersistentVolumeSource.Cinder != nil && x.Cinder != nil
			yyq290[9] = x.PersistentVolumeSource.CephFS != nil && x.CephFS != nil
			yyq290[10] = x.PersistentVolumeSource.FC != nil && x.FC != nil
			yyq290[11] = x.PersistentVolumeSource.Flocker != nil && x.Flocker != nil
			yyq290[12] = x.PersistentVolumeSource.FlexVolume != nil && x.FlexVolume != nil
			yyq290[13] = len(x.AccessModes) != 0
			yyq290[14] = x.ClaimRef != nil
			yyq290[15] = x.PersistentVolumeReclaimPolicy != ""
			var yynn290 int
			if yyr290 || yy2arr290 {
				r.EncodeArrayStart(16)
			} else {
				yynn290 = 0
				for _, b := range yyq290 {
					if b {
						yynn290++
					}
				}
				r.EncodeMapStart(yynn290)
				yynn290 = 0
			}
			if yyr290 || yy2arr290 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq290[0] {
					if x.Capacity == nil {
						r.EncodeNil()
					} else {
						x.Capacity.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq290[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("capacity"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Capacity == nil {
						r.EncodeNil()
					} else {
						x.Capacity.CodecEncodeSelf(e)
					}
				}
			}
			var yyn292 bool
			if x.PersistentVolumeSource.GCEPersistentDisk == nil {
				yyn292 = true
				goto LABEL292
			}
		LABEL292:
			if yyr290 || yy2arr290 {
				if yyn292 {
					r.EncodeNil()
				} else {
					z.EncSendCont


 =
      GeneratedColumn<String?>('CODIGO_PEDIDO_EMPRESA', aliasedName, true,
          additionalChecks: GeneratedColumn.checkTextLength(
              minTextLength: 0, maxTextLength: 100),
          type: const StringType(),
          requiredDuringInsert: false);
  final VerificationMeta _conteudoJsonMeta =
      const VerificationMeta('conteudoJson');
  @override
  late final GeneratedColumn<String?> conteudoJson = GeneratedColumn<String?>(
      'CONTEUDO_JSON', aliasedName, true,
      additionalChecks:
          GeneratedColumn.checkTextLength(minTextLength: 0, maxTextLength: 250),
      type: const StringType(),
      requiredDuringInsert: false);
  final VerificationMeta _observacaoMeta = const VerificationMeta('observacao');
  @override
  late final GeneratedColumn<String?> observacao = GeneratedColumn<String?>(
      'OBSERVACAO', aliasedName, true,
      additionalChecks:
          GeneratedColumn.checkTextLength(minTextLength: 0, maxTextLength: 250),
      type: const StringType(),
      requiredDuringInsert: false);
  final VerificationMeta _dataSolicitacaoMeta =
      const VerificationMeta('dataSolicitacao');
  @override
  late final GeneratedColumn<DateTime?> dataSolicitacao =
      GeneratedColumn<DateTime?>('DATA_SOLICITACAO', aliasedName, true,
          type: const IntType(), requiredDuringInsert: false);
  final VerificationMeta _horaSolicitacaoMeta =
      const VerificationMeta('horaSolicitacao');
  @override
  late final GeneratedColumn<String?> horaSolicitacao =
      GeneratedColumn<String?>('HORA_SOLICITACAO', aliasedName, true,
          additionalChecks: GeneratedColumn.checkTextLength(
              minTextLength: 0, maxTextLength: 8),
          type: const StringType(),
          requiredDuringInsert: false);
  @override
  List<GeneratedColumn> get $columns => [
        id,
        codigoPedidoEmpresa,
        conteudoJson,
        observacao,
        dataSolicitacao,
        horaSolicitacao
      ];
  @override
  String get aliasedName => _alias ?? 'EMPRESA_DELIVERY_PEDIDO';
  @override
  String get actualTableName => 'EMPRESA_DELIVERY_PEDIDO';
  @override
  VerificationContext validateIntegrity(
      Insertable<EmpresaDeliveryPedido> instance,
      {bool isInserting = false}) {
    final context = VerificationContext();
    final data = instance.toColumns(true);
    if (data.containsKey('ID')) {
      context.handle(_idMeta, id.isAcceptableOrUnknown(data['ID']!, _idMeta));
    }
    if (data.containsKey('CODIGO_PEDIDO_EMPRESA')) {
      context.handle(
          _codigoPedidoEmpresaMeta,
          codigoPedidoEmpresa.isAcceptableOrUnknown(
              data['CODIGO_PEDIDO_EMPRESA']!, _codigoPedidoEmpresaMeta));
    }
    if (data.containsKey('CONTEUDO_JSON')) {
      context.handle(
          _conteudoJsonMeta,
          conteudoJson.isAcceptableOrUnknown(
              data['CONTEUDO_JSON']!, _conteudoJsonMeta));
    }
    if (data.containsKey('OBSERVACAO')) {
      context.handle(
          _observacaoMeta,
          observacao.isAcceptableOrUnknown(
              data['OBSERVACAO']!, _observacaoMeta));
    }
    if (data.containsKey('DATA_SOLICITACAO')) {
      context.handle(
          _dataSolicitacaoMeta,
          dataSolicitacao.isAcceptableOrUnknown(
              da


;

    /// <inheritdoc />
    [AllowNull]
    public string ConnectionString
    {
        get => _innerBuilder.ConnectionString;
        set => _innerBuilder.ConnectionString = value;
    }

    /// <inheritdoc />
    public object? this[string keyword]
    {
        get => _innerBuilder[keyword];
        set => _innerBuilder[keyword] = value;
    }

    public DbConnectionStringBuilderWrapper(DbConnectionStringBuilder innerBuilder)
    {
        ArgumentNullException.ThrowIfNull(innerBuilder);

        _innerBuilder = innerBuilder;
    }
}


eatures: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropKeyDerivation: EAP_METHOD_PROPERTY_TYPE = 5i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropKeyStrength64: EAP_METHOD_PROPERTY_TYPE = 6i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropKeyStrength128: EAP_METHOD_PROPERTY_TYPE = 7i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropKeyStrength256: EAP_METHOD_PROPERTY_TYPE = 8i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropKeyStrength512: EAP_METHOD_PROPERTY_TYPE = 9i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropKeyStrength1024: EAP_METHOD_PROPERTY_TYPE = 10i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropDictionaryAttackResistance: EAP_METHOD_PROPERTY_TYPE = 11i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropFastReconnect: EAP_METHOD_PROPERTY_TYPE = 12i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropCryptoBinding: EAP_METHOD_PROPERTY_TYPE = 13i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropSessionIndependence: EAP_METHOD_PROPERTY_TYPE = 14i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropFragmentation: EAP_METHOD_PROPERTY_TYPE = 15i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropChannelBinding: EAP_METHOD_PROPERTY_TYPE = 16i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropNap: EAP_METHOD_PROPERTY_TYPE = 17i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropStandalone: EAP_METHOD_PROPERTY_TYPE = 18i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropMppeEncryption: EAP_METHOD_PROPERTY_TYPE = 19i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropTunnelMethod: EAP_METHOD_PROPERTY_TYPE = 20i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropSupportsConfig: EAP_METHOD_PROPERTY_TYPE = 21i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropCertifiedMethod: EAP_METHOD_PROPERTY_TYPE = 22i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropHiddenMethod: EAP_METHOD_PROPERTY_TYPE = 23i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropMachineAuth: EAP_METHOD_PROPERTY_TYPE = 24i32;
#[doc = "*Required features: 'Win32_Security_ExtensibleAuthenticationProtocol'*"]
pub const emptPropUserAuth: EAP_METHOD_PROPERTY_TYPE = 25i32;
#[doc = "*Required features: '


LDR(r3, r2, m68k_write16_map)
    bic     r0, r0, #0xff000000
    mov     r2, r0, lsr #16
    ldr     r3, [r3, r2, lsl #2]
    bic     r0, r0, #1
    movs    r3, r3, lsl #1
    movcc   r2, r1, lsr #16
    strcch  r2, [r3, r0]!
    s


.dispatch).toHaveBeenCalledTimes(1);
      expect(store.dispatch).toHaveBeenCalledWith({
        payload: {
          edgeIds: ['edge-2'],
          nodeIds: ['node-1', 'node-2'],
        },
        type: GlobalActionsType.DELETE_ITEMS,
      });
    });
  });
});
import mysql from '../core/mysql'

export default {
    TYPE_TAG: 1, // 常规标签
    TYPE_CATEGORY: 2, // 分类标签
    async getTypeTags(type: number) {
        let conn = await mysql.getConnection()
        let [list] = await conn.query(`select t.name, t.id, COUNT(*) as num from tag AS t JOIN article_tag as a_t ON t.id = a_t.tag_id WHERE t.type = ? GROUP BY t.id`, [type])
        return list
    },
    async getCategories() {
        return this.getTypeTags(this.TYPE_CATEGORY)
    },
    async getTags() {
        return this.getTypeTags(this.TYPE_TAG)
    },
    async getTagByName(name: string) {
        let conn = await mysql.getConnection()
        let [res] = await conn.query(`SELECT id FROM tag where name = ?`, [name])
        return res && res[0]
    },
    // 增加标签
    async addTag(name: string, type: number) {
        let conn = await mysql.getConnection()
        let [res] = await conn.query(`INSERT INTO tag (name, type) VALUES (?, ?)`, [name, type])
        return res && res.insertId
    },
    // 关联标签和文章
    async bindArticleTag(tagId: number, articleId: number) {
        let conn = await mysql.getConnection()
        let [res] = await conn.query(`INSERT INTO article_tag (article_id, tag_id) VALUES (?, ?)`, [articleId, tagId])
        return res && res.insertId
    }
}
import { CoursesService, getNewId } from './courses.service';

import { ICourse } from 'src/app/components/courses/interfaces/courses.interface';

describe('CoursesService', () => {
  let service: CoursesService;
  const coursesMock: ICourse[] = [
    { id: 1, title: 'Course1' },
    { id: 2, title: 'Course2' },
    { id: 3, title: 'Course3' }
  ] as ICourse[];

  beforeEach(() => {
    service = new CoursesService();
    service.courses = [...coursesMock]; // spread for copy instead of link
  });

  it('should be created', () => {
    expect(service).toBeTruthy();
  });

  describe('#getCourses()', () => {
    it('should return array of courses', () => {
      expect(service.getCourses()).toEqual(coursesMock);
    });
  });

  describe('#getCourseById()', () => {
    it('should return pointed course if it exists', () => {
      expect(service.getCourseById(1)).toEqual(coursesMock[0]);
    });

    it('should return empty object if course doest exist', () => {
      expect(service.getCourseById(4)).toEqual({});
    });
  });

  describe('#createCourse()', () => {
    it('should add new course to the source', () => {
      const newCourse = { title: 'NewCourse4' } as ICourse;

      expect(service.getCourses().length).toBe(3);

      service.createCourse(newCourse);

      expect(service.getCourses().length).toBe(4);
      expect(service.getCourseById(4)).toEqual({ id: 4, ...newCourse });
    });
  });

  describe('#updateCourse()', () => {
    it('should update pointed course in the source', () => {
      const newCourseData = { title: 'NewCourse3' } as ICourse;

      expect(service.getCourseById(3)).toEqual(coursesMock[2]);

      service.updateCourse(3, newCourseData);

      expect(service.get


class="form-group">
                From

                    <select class="form-control" id="mms-from"></select>

                To

                    <input type="text" class="form-control" id="mms-to" name="to">

                Attachment

                    <input type="file" class="form-control" id="mms-attachment" name="attachment" multiple="multiple">

                Attached files

            <button type="submit" class="btn btn-primary"> Send MMS</button>

    </form>

        © 1999 –  RingCentral™, Inc. All rights reserved.


"""
문제의 핵심 포인트:
각 노드는 값과 이웃 노드들의 리스트를 가짐
원본 그래프와 완전히 독립적인 새로운 그래프 생성
모든 연결 관계를 그대로 복사

해결 방법:
DFS(깊이 우선 탐색) + 해시맵을 사용함:
해시맵으로 원본 노드와 복사본 노드의 매핑 관계 저장
DFS로 그래프를 순회하면서 각 노드를 복사
이미 복사된 노드는 해시맵에서 찾아서 재사용

Example 1의 경우
1 --- 2
|     |
|     |
4 --- 3

실행 과정:
노드 1 복사: clone_1 생성, visited = clone_1
노드 1의 이웃 2 복사: clone_2 생성, visited = clone_2
노드 2의 이웃 1 처리: 이미 visited에 있으므로 clone_1 반환
노드 2의 이웃 3 복사: clone_3 생성, visited = clone_3
노드 3의 이웃들 처리: clone_2, clone_4 연결
노드 1의 이웃 4 복사: clone_4 생성, visited = clone_4
모든 연결 관계 완성
Output: 원본과 동일한 구조의 완전히 새로운 그래프

시간 복잡도: O(V + E)
V: 노드(정점)의 개수, E: 간선의 개수
각 노드를 한 번씩 방문하고, 각 간선을 한 번씩 처리
DFS의 표준 시간 복잡도

공간 복잡도: O(V)
visited 해시맵이 모든 노드를 저장: O(V)
DFS 재귀 호출 스택의 최대 깊이: O(V)
복사된 그래프 자체도 O(V + E)의 공간 필요
"""

from typing import Optional
class Solution:
    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
        # 빈 그래프인 경우 None 반환
        if not node:
            return None

        # 원본 노드를 키로, 복사본 노드를 값으로 하는 해시맵 생성
        # 중복 복사를 방지하고 순환 참조 문제 해결
        visited = {}

        # DFS 함수 정의
        def dfs(original_node):
            # 이미 복사된 노드라면 기존 복사본을 반환 (중복 복사 방지)
            if original_node in visited:
                return visited[original_node]

            # 원본 노드의 값으로 새로운 노드 생성
            # 이웃 리스트는 빈 리스트로 초기화
            clone_node = Node(original_node.val, [])

            # 해시맵에 원본-복사본 매핑 관계 저장
            # 순환 참조 방지를 위해 이웃을 처리하기 전에 먼저 저장
            visited[original_node] = clone_node

            # 원본 노드의 모든 이웃들을 재귀적으로 복사
            # 복사된 이웃 노드들을 현재 복사본의 이웃 리스트에 추가
            for neighbor in original_node.neighbors:
                # 이웃 노드를 복사하고 현재 노드의 이웃 리스트에 추가
                clone_node.neighbors.append(dfs(neighbor))

            # 완성된 복사본 노드 반환
            return clone_node

        # 주어진 노드부터 DFS 시작
        return dfs(node)


農產品則上漲375.7%。

   （六）山貨土產：山貨土產及各種特種農產品的收購、推銷，可以加強城鄉交流，提高農民收入，並為國家換取大量的外匯。故各省有關專業公司對此經營不遺餘力。如對於各種油脂的收購：華北、華中、華東三區一年來收購生仁3,172公噸，生油6,860公噸，棉油1,042公噸，胡麻油169公噸，菜籽油660公噸，豆油1,095公噸，豆餅96,500公噸，各種油籽7,480公噸，各種食油5,500公噸，茶油2,600公噸，青油200公噸，桐油3,000公噸。又如對於豬鬃的收購，解放後華北、華東、華中、西北各區共收購3,609,820磅。又如皮毛的收購，華北、西北兩區各種皮類共1,468,228張，牛皮113,840斤，羊皮1,154,900斤，絨毛6,192,872斤，各種腸類60729把，地毯104,984方呎。

   綜上所述，1949年的城鄉交流工作是獲得了一定的成績的。其中，國營貿易公司起着領導的作用，且日益提高其比重。以上海為例，自9月至12月4個月中，國營貿易機關在上海主要商品市場成交量的逐月增加率，遠比上海主要商品市場總成交量的逐月增加率為大。

   9月 10月 11月 12月   上海主要商品市場總成交量 100 165.2 143.2 159   上海國營貿易主要商品成交量 100 204.4 310.4 517

   又據不完全的資料，在華東16個城市（上海、南京、青島、濟南、煙台、徐州、蚌埠、蕪湖、杭州、無錫、金華、湖州、溫州、廈門、泉州、福州）1949年12月份的主要批發市場上，國營商品的流轉約佔總週轉量的42%。分別言之，大米市場我進出量佔總成交量的36.49%。麵粉43.02%，食


 corresponding
parameter indices in the tape for the initial value of the corresponding
vec_ad element.

\par 2DO
All these operates are preformed in \c Rec_, so we should
move this routine from <tt>ADTape<Base></tt> to <tt>recorder<Base></tt>.
*/
template <class Base>
size_t ADTape<Base>::AddVec(size_t length, const pod_vector<Base>& data)
{	CPPAD_ASSERT_UNKNOWN( length > 0 );
	size_t i;
	size_t value_index;

	// store the length in VecInd
	size_t start = Rec_.PutVecInd(length);

	// store indices of the values in VecInd
	for(i = 0; i < length; i++)
	{
		value_index = Rec_.PutPar( data[i] );
		Rec_.PutVecInd( value_index );
	}

	// return the taddr of the length (where the vector starts)
	return start;
}

} // END_CPPAD_NAMESPACE

# endif
/* $Id$ */
# ifndef CPPAD_DIV_EQ_INCLUDED
# define CPPAD_DIV_EQ_INCLUDED

/* --------------------------------------------------------------------------
CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 Bradley M. Bell

CppAD is distributed under multiple licenses. This distribution is under
the terms of the
                    GNU General Public License Version 3.

A copy of this license is included in the COPYING file of this distribution.
Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
-------------------------------------------------------------------------- */

//  BEGIN CppAD namespace
namespace CppAD {

template <class Base>
AD<Base>& AD<Base>::operator /= (const AD<Base> &right)
{
	// compute the Base part
	Base left;
	left    = value_;
	value_ /= right.value_;

	// check if there is a recording in progress
	ADTape<Base>* tape = AD<Base>::tape_ptr();
	if( tape == CPPAD_NULL )
		return *this;
	tape_id_t tape_id = tape->id_;

	// tape_id cannot match the default value for tape_id_; i.e., 0
	CPPAD_ASSERT_UNKNOWN( tape_id > 0 );
	bool var_left  = tape_id_       == tape_id;
	bool var_right = right.tape_id_ == tape_id;

	if( var_left )
	{	if( var_right )
		{	// this = variable / variable
			CPPAD_ASSERT_UNKNOWN( NumRes(DivvvOp) == 1 );
			CPPAD_ASSERT_UNKNOWN( NumArg(DivvvOp) == 2 );

			// put operand addresses in tape
			tape->Rec_.PutArg(taddr_, right.taddr_);
			// put operator in the tape
			taddr_ = tape->Rec_.PutOp(DivvvOp);
			// make this a variable
			CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
		}
		else if( IdenticalOne( right.value_ ) )
		{	// this = variable * 1
		}
		else
		{	// this = variable / parameter
			CPPAD_ASSERT_UNKNOWN( NumRes(DivvpOp) == 1 );
			CPPAD_ASSERT_UNKNOWN( NumArg(DivvpOp) == 2 );

			// put operand addresses in tape
			addr_t p = tape->Rec_.PutPar(right.value_);
			tape->Rec_.PutArg(taddr_, p);
			// put operator in the tape
			taddr_ = tape->Rec_.PutOp(DivvpOp);
			// make this a variable
			CPPAD_ASSERT_UNKNOWN( tape_id_ == tape_id );
		}
	}
	else if( var_right  )
	{	if( IdenticalZero(left) )
		{	// this = 0 / variable
		}
		else
		{	// this = parameter / variable
			CPPAD_ASSERT_UNKNOWN( NumRes(DivpvOp) == 1 );
			CPPAD_ASSERT_UNKNOWN( NumArg(DivpvOp) == 2 );

			// put operand addresses in tape
			addr_t p = tape->Rec_.PutPar(left);
			tape->Rec_.PutArg(p, right.taddr_);
			// put operator in the tape
			taddr_ = tape->Rec_.PutOp(DivpvOp);
			// make t