|scripting components|ASCII (character|number)|localized string|choose (application|color|file|file name|folder|from list|remote application|URL)|display (alert|dialog))\\b|^\\s*return\\b"},{cN:"constant",b:"\\b(text item delimiters|current application|missing value)\\b"},{cN:"keyword",b:"\\b(apart from|aside from|instead of|out of|greater than|isn't|(doesn't|does not) (equal|come before|come after|contain)|(greater|less) than( or equal)?|(starts?|ends|begins?) with|contained by|comes (before|after)|a (ref|reference))\\b"},{cN:"property",b:"\\b(POSIX path|(date|time) string|quoted form)\\b"},{cN:"function_start",bK:"on",i:"[${=;\\n]",c:[e.UTM,r]}].concat(a),i:"//|->|=>"}});hljs.registerLanguage("makefile",function(e){var a={cN:"variable",b:/\$\(/,e:/\)/,c:[e.BE]};return{aliases:["mk","mak"],c:[e.HCM,{b:/^\w+\s*\W*=/,rB:!0,r:0,starts:{cN:"constant",e:/\s*\W*=/,eE:!0,starts:{e:/$/,r:0,c:[a]}}},{cN:"title",b:/^[\w]+:\s*$/},{cN:"phony",b:/^\.PHONY:/,e:/$/,k:".PHONY",l:/[\.\w]+/},{b:/^\t+/,e:/$/,r:0,c:[e.QSM,a]}]}});hljs.registerLanguage("dust",function(e){var a="if eq ne lt lte gt gte select default math sep";return{aliases:["dst"],cI:!0,sL:"xml",subLanguageMode:"continuous",c:[{cN:"expression",b:"{",e:"}",r:0,c:[{cN:"begin-block",b:"#[a-zA-Z- .]+",k:a},{cN:"string",b:'"',e:'"'},{cN:"end-block",b:"\\/[a-zA-Z- .]+",k:a},{cN:"variable",b:"[a-zA-Z-.]+",k:a,r:0}]}]}});hljs.registerLanguage("clojure-repl",function(e){return{c:[{cN:"prompt",b:/^([\w.-]+|\s*#_)=>/,starts:{e:/$/,sL:"clojure",subLanguageMode:"continuous"}}]}});hljs.registerLanguage("dart",function(e){var t={cN:"subst",b:"\\$\\{",e:"}",k:"true false null this is new super"},r={cN:"string",v:[{b:"r'''",e:"'''"},{b:'r"""',e:'"""'},{b:"r'",e:"'",i:"\\n"},{b:'r"',e:'"',i:"\\n"},{b:"'''",e:"'''",c:[e.BE,t]},{b:'"""',e:'"""',c:[e.BE,t]},{b:"'",e:"'",i:"\\n",c:[e.BE,t]},{b:'"',e:'"',i:"\\n",c:[e.BE,t]}]};t.c=[e.CNM,r];var n={keyword:"assert break case catch class const continue default do else enum extends false final finally for if in is new null rethrow return super switch this throw true try var void while with",literal:"abstract as dynamic export external factory get implements import library operator part set static typedef",built_in:"print Comparable DateTime Duration Function Iterable Iterator List Map Match Null Object Pattern RegExp Set Stopwatch String StringBuffer StringSink Symbol Type Uri bool double int num document window querySelector querySelectorAll Element ElementList"};return{k:n,c:[r,{cN:"dartdoc",b:"/\\*\\*",e:"\\*/",sL:"markdown",subLanguageMode:"continuous"},{cN:"dartdoc",b:"///",e:"$",sL:"markdown",subLanguageMode:"continuous"},e.CLCM,e.CBCM,{cN:"class",bK:"class interface",e:"{",eE:!0,c:[{bK:"extends implements"},e.UTM]},e.CNM,{cN:"annotation",b:"@[A-Za-z]+"},{b:"=>"}]}});/*!
  * Bootstrap v5.0.2 (https://getbootstrap.com/)
  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  */
import*as


onText = "Submit";
      },() => {
      }
    );
  } */
}export class Sort {
    private field: string;
    private type: string;

    constructor(_field: string,
                _type: string){
        this.field = _field;
        this.type = _type;
    }

    getName(): string {
        return this.field;
    }
    getType(): string {
        return this.type;
    }
}
import { createReducer, on } from '@ngrx/store';
import { Usuario } from 'src/app/models/usuario.model';
import {cargarUsuarios,cargarUsuariosError,cargarUsuariosSuccess} from '../actions';

export interface UsuariosState {
    users:Usuario[],
    loaded:boolean,
    loadeding:boolean,
    error:any,

};

const usuariosInitialState: UsuariosState = {
    users  : [],
    loaded : false,
    loadeding : false,
    error : null

};

const _usuariosReducer = createReducer(usuariosInitialState,

    on(cargarUsuarios, state => ({ ...state, loadeding: true})),
    on(cargarUsuariosSuccess,(state,{usuarios}) => ({
        ...state,
        loadeding:false,
        loaded:true,
        users:[...usuarios]
    })),
    on(cargarUsuariosError,(state,{payload}) => ({
        ...state,
        loadeding:false,
        loaded:false,
        error:{
            url:payload.url,
            message:payload.message,
            status:payload.status
        }
    })),
);

export function usuariosReducer(state, action) {
    return _usuariosReducer(state, action);
}// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
// See LICENSE in the project root for license information.

import * as path from 'path';
import * as webpack from 'webpack';
import { ConcatSource } from 'webpack-sources';
import type {
  IAssetInfo,
  IModuleMap,
  IModuleInfo,
  IExtendedModule,
  _IAcornComment
} from './ModuleMinifierPlugin.types';

function getAllComments(moduleIds: (string | number)[], minifiedModules: IModuleMap): Set<string> {
  const allComments: Set<string> = new Set();

  for (const moduleId of moduleIds) {
    const mod: IModuleInfo | undefined = minifiedModules.get(moduleId);
    if (!mod) {
      continue;
    }

    const { module: webpackModule } = mod;
    const modules: IExtendedModule[] = webpackModule.modules || [webpackModule];
    for (const submodule of modules) {
      const { comments: subModuleComments } = submodule.factoryMeta as {
        comments?: Set<_IAcornComment>;
      };
      if (subModuleComments) {
        for (const comment of subModuleComments) {
          const value: string = comment.type === 'Line' ? `//${comment.value}\n` : `/*${comment.value}*/\n`;
          allComments.add(value);
        }
      }
    }
  }

  return allComments;
}

/**
 * Generates a companion asset containing all extracted comments. If it is non-empty, returns a banner comment directing users to said companion asset.
 *
 * @param compilation - The webpack compilation
 * @param asset - The asset to process
 * @param minifiedModules - The minified modules to pull comments from
 * @param assetName - The name of the asset
 * @public
 */
export function generateLicenseFileForAsset(
  compilation: webpack.compilation.Compilation,
  asset: IAssetInfo,


.tl-timemarker .tl-timemarker-content-container .tl-timemarker-content.tl-timemarker-content-small .tl-timemarker-media-container [class^="tl-icon-"],
.tl-timemarker .tl-timemarker-content-container .tl-timemarker-content.tl-timemarker-content-small .tl-timemarker-media-container [class*=" tl-icon-"] {
  font-size: 12px;
}
.tl-timemarker:hover .tl-timemarker-timespan {
  background-color: rgba(77, 77, 77, 0.15);
}
.tl-timemarker:hover .tl-timemarker-timespan .tl-timemarker-timespan-content {
  background-color: #4d4d4d;
}
.tl-timemarker:hover .tl-timemarker-timespan .tl-timemarker-line-left,
.tl-timemarker:hover .tl-timemarker-timespan .tl-timemarker-line-right {
  border-color: #000000;
}
.tl-timemarker:hover .tl-timemarker-timespan .tl-timemarker-line-left:after,
.tl-timemarker:hover .tl-timemarker-timespan .tl-timemarker-line-right:after {
  background-color: #ffffff;
}
.tl-timemarker:hover .tl-timemarker-content-container {
  background-color: #000000;
  border-color: #000000;
  -webkit-transition: height 250ms cubic-bezier(0.77, 0, 0.175, 1), width 250ms cubic-bezier(0.77, 0, 0.175, 1);
  -moz-transition: height 250ms cubic-bezier(0.77, 0, 0.175, 1), width 250ms cubic-bezier(0.77, 0, 0.175, 1);
  -o-transition: height 250ms cubic-bezier(0.77, 0, 0.175, 1), width 250ms cubic-bezier(0.77, 0, 0.175, 1);
  transition: height 250ms cubic-bezier(0.77, 0, 0.175, 1), width 250ms cubic-bezier(0.77, 0, 0.175, 1);
}
.tl-timemarker:hover .tl-timemarker-content-container.tl-timemarker-content-container-small {
  width: 200px;
}
.tl-timemarker:hover .tl-timemarker-content-container .tl-timemarker-content .tl-timemarker-text h2.tl-headline {
  color: #FFF;
}
.tl-timemarker:hover .tl-timemarker-content-container .tl-timemarker-content .tl-timemarker-text h2.tl-headline.tl-headline-fadeout:after {
  background: -moz-linear-gradient(top, rgba(0, 0, 0, 0) 0%, #000000 80%);
  /* FF3.6+ */
  background: -webkit-gradient(linear, left top, left bottom, color-stop(0%, rgba(0, 0, 0, 0)), color-stop(80%, #000000));
  /* Chrome,Safari4+ */
  background: -webkit-linear-gradient(top, rgba(0, 0, 0, 0) 0%, #000000 80%);
  /* Chrome10+,Safari5.1+ */
  background: -o-linear-gradient(top, rgba(0, 0, 0, 0) 0%, #000000 80%);
  /* Opera 11.10+ */
  background: -ms-linear-gradient(top, rgba(0, 0, 0, 0) 0%, #000000 80%);
  /* IE10+ */
  background: linear-gradient(to bottom, rgba(0, 0, 0, 0) 0%, #000000 80%);
  /* W3C */
  filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='@thecolor', endColorstr='@thecolor',


@reflectiveTest
class AnalysisOptionsGeneratorTest extends YamlGeneratorTest
    with LintRegistrationMixin {
  @override
  String get fileName => 'analysis_options.yaml';

  @override
  AnalysisOptionsGenerator get generator =>
      AnalysisOptionsGenerator(resourceProvider);

  void setUp() {
    registerLintRules();
  }

  void tearDown() {
    unregisterLintRules();
  }

  void test_analyzer() {
    getCompletions('''
analyzer:
  ^
''');
    assertSuggestion('${AnalysisOptionsFile.enableExperiment}:');
  }

  void test_analyzer_enableExperiment() {
    getCompletions('''
analyzer:
  enable-experiment:
    ^
''');
    assertSuggestion('macros');
    assertNoSuggestion('super-parameters');
  }

  void test_analyzer_enableExperiment_nonDuplicate() {
    getCompletions('''
analyzer:
  enable-experiment:
    - macros
    ^
''');
    assertNoSuggestion('macros');
  }

  void test_analyzer_errors() {
    getCompletions('''
analyzer:
  errors:
    ^
''');
    assertSuggestion('dead_code: ');
    assertSuggestion('invalid_assignment: ');
    assertSuggestion('annotate_overrides: ');
  }

  void test_analyzer_errors_excludesExisting() {
    getCompletions('''
analyzer:
  errors:
    dead_code: info
    ^
''');
    assertNoSuggestion('dead_code');
  }

  void test_analyzer_errors_noDuplicates() {
    getCompletions('''
analyzer:
  errors:
    ^
''');
    var duplicateCompletions = groupBy(
      results.map((result) => result.completion),
      (result) => result,
    ).entries.where((entry) => entry.value.length > 1).keys;
    expect(duplicateCompletions, isEmpty);
  }

  void test_analyzer_errors_severity() {
    getCompletions('''
analyzer:
  errors:
    dead_code: ^
''');
    assertSuggestion('ignore');
    assertSuggestion('info');
    assertSuggestion('warning');
    assertSuggestion('error');
  }

  void test_analyzer_language_strictCasts() {
    getCompletions('''
analyzer:
  language:
    strict-casts: ^
''');
    assertSuggestion('false');
    assertSuggestion('true');
  }

  void test_analyzer_language_strictInference() {
    getCompletions('''
analyzer:
  language:
    strict-inference: ^
''');
    assertSuggestion('false');
    assertSuggestion('true');
  }

  void test_analyzer_language_strictRawTypes() {
    getCompletions('''
analyzer:
  language:
    strict-raw-types: ^
''');
    assertSuggestion('false');
    assertSuggestion('true');
  }

  void test_codeStyle() {
    getCompletions('''
code-style:
  ^
''');
    assertSuggestion('${AnalysisOptionsFile.format}: ');
  }

  void test_codeStyle_format() {
    getCompletions('''
code-style:
  format: ^
''');
    assertSuggestion('false');
    assertSuggestion('true');
  }

  void test_empty() {
    getCompletions('^');
    assertSuggestion('${AnalysisOptionsFile.analyzer}: ');
    assertSuggestion('${AnalysisOptionsFile.codeStyle}: ');
    assertSuggestion('${AnalysisOptionsFile.formatter}: ');
    assertSuggestion('${AnalysisOptionsFile.include}: ');
    // TODO(brianwilkerson): Replace this with a constant.
    assertSuggestion('linter: ');


ct>
// CHECK-NEXT:    <key>line</key><integer>42</integer>
// CHECK-NEXT:    <key>col</key><integer>3</integer>
// CHECK-NEXT:    <key>file</key><integer>0</integer>
// CHECK-NEXT:   </dict>
// CHECK-NEXT:  <key>name</key><string>SET_PTR_VAR_TO_NULL_WITH_NESTED_MACRO</string>
// CHECK-NEXT:  <key>expansion</key><string>ptr =0</string>
// CHECK-NEXT:  </dict>
// CHECK-NEXT: </array>

//===----------------------------------------------------------------------===//
// Tests for function-like macro expansions.
//===----------------------------------------------------------------------===//

void setToNull(int **vptr) {
  *vptr = nullptr;
}

#define TO_NULL(x) \
  setToNull(x)

void functionLikeMacroTest() {
  int *ptr;
  TO_NULL(&ptr);
  *ptr = 5; // expected-warning{{Dereference of null pointer}}
}

// CHECK:      <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT:  <dict>
// CHECK-NEXT:   <key>location</key>
// CHECK-NEXT:   <dict>
// CHECK-NEXT:    <key>line</key><integer>73</integer>
// CHECK-NEXT:    <key>col</key><integer>3</integer>
// CHECK-NEXT:    <key>file</key><integer>0</integer>
// CHECK-NEXT:   </dict>
// CHECK-NEXT:  <key>name</key><string>TO_NULL(&ptr)</string>
// CHECK-NEXT:  <key>expansion</key><string>setToNull (&ptr )</string>
// CHECK-NEXT:  </dict>
// CHECK-NEXT: </array>

#define DOES_NOTHING(x) \
  {                     \
    int b;              \
    b = 5;              \
  }                     \
  print(x)

#define DEREF(x)   \
  DOES_NOTHING(x); \
  *x

void functionLikeNestedMacroTest() {
  int *a;
  TO_NULL(&a);
  DEREF(a) = 5; // expected-warning{{Dereference of null pointer}}
}

// CHECK:      <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT:  <dict>
// CHECK-NEXT:   <key>location</key>
// CHECK-NEXT:   <dict>
// CHECK-NEXT:    <key>line</key><integer>104</integer>
// CHECK-NEXT:    <key>col</key><integer>3</integer>
// CHECK-NEXT:    <key>file</key><integer>0</integer>
// CHECK-NEXT:   </dict>
// CHECK-NEXT:   <key>name</key><string>TO_NULL(&a)</string>
// CHECK-NEXT:   <key>expansion</key><string>setToNull (&a )</string>
// CHECK-NEXT:  </dict>
// CHECK-NEXT:  <dict>
// CHECK-NEXT:   <key>location</key>
// CHECK-NEXT:   <dict>
// CHECK-NEXT:    <key>line</key><integer>105</integer>
// CHECK-NEXT:    <key>col</key><integer>3</integer>
// CHECK-NEXT:    <key>file</key><integer>0</integer>
// CHECK-NEXT:   </dict>
// CHECK-NEXT:   <key>name</key><string>DEREF(a)</string>
// CHECK-NEXT:   <key>expansion</key><string>{int b ;b =5;}print (a );*a </string>
// CHECK-NEXT:  </dict>
// CHECK-NEXT: </array>

//===----------------------------------------------------------------------===//
// Tests for undefining and/or redifining macros.
//===----------------------------------------------------------------------===//

#define WILL_UNDEF_SET_NULL_


cursor: pointer;
    margin-left: 10px;
    min-width: 90px;    /* Added minimum width */
    white-space: nowrap; /* Prevent text wrapping */
}

#signUpBtn {
    width: auto;      /* Allow button to fit content */
    padding: 10px 20px;
}

nav button:hover {
    transform: scale(0.95);
    background: #f79c42;
}

.home {
    display: flex;
    align-items: center;
    justify-content: space-between;
    min-height: 100vh;
    padding: 50px;
}

.home .content {
    color: #fff;
    max-width: 500px;
}

.home h2 {
    font-size: 48px;
    text-transform: uppercase;
    color: #fff;
    line-height: 1.5;
}

.home p {
    font-size: 24px;
    margin-top: 15px;
    color: #eee;
    line-height: 1.8;
}

.home button {
    margin-top: 30px;
    background: #e78f38;
    border: 2px solid #e78f38;
    color: #fff;
    padding: 15px 40px;  /* Increased padding */
    font-size: 18px;     /* Increased font size */
    font-weight: 600;
    border-radius: 25px; /* Slightly larger border radius */
    transition: 0.3s ease;
    cursor: pointer;
}

.home button:hover {
    transform: scale(1.05); /* Slightly larger scale on hover */
    background: #f79c42;    /* Lighter orange on hover */
}

.home button.know_more {
    background: transparent;
    border: 2px solid #e78f38;
    color: #eee;
    margin-left: 20px;
    padding: 15px 40px;  /* Match the main button size */
    font-size: 18px;     /* Match the main button size */
}

.home img {
    width: 450px;
    height: auto;
    margin-left: 20px;
    animation: zoomInOut 2s infinite;
    filter:
        drop-shadow(0px 5px 55px rgba(255, 69, 0, 0.9))
        drop-shadow(0px 10px 100px rgba(255, 140, 0, 0.7))
        drop-shadow(0px 15px 300px rgba(255, 215, 0, 0.5));
    transition: filter 2s ease-in-out;
}

@keyframes zoomInOut {
    0% {
        transform: scale(1);
    }
    50% {
        transform: scale(1.1);
    }
    100% {
        transform: scale(1);
    }
}

/* Background overlay */
.modal-overlay {
    display: none;
    position: fixed;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    background: rgba(0, 0, 0, 0.6);
    z-index: 999;
    opacity: 0;
    transition: opacity 0.4s ease-in-out;
}

/* Modal Styles */
.modal {
    display: none; /* Hidden by default */
    position: fixed;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%) scale(0.8);
    z-index: 1000;
    background-color: #fff;
    box-shadow: 0 8px 20px rgba(0, 0, 0, 0.3);
    border-radius: 10px;
    padding: 20px;
    width: 80%;
    max-width: 500px;
    opacity: 0;
    transition: all 0.4s ease-in-out;
}

/* Modal when active */
.modal.show {
    display: block;
    opacity: 1;
    transform: t


       return isMutable;
    }

   /* Validates the responseId in the SAML Response. */
    protected void validateID(String responseId) throws SAML2Exception {
        if ((responseId == null) || (responseId.length() == 0 )) {
            SAML2SDKUtils.debug.message("ID is missing in the SAMLResponse");
            throw new SAML2Exception(
            SAML2SDKUtils.bundle.getString("missingIDAttr"));
        }
    }

   /* Validates the version in the SAML Response. */
    protected void validateVersion(String version) throws SAML2Exception {
        if ((version == null) || (version.length() == 0) ) {
            throw new SAML2Exception(SAML2SDKUtils.bundle.getString(
            "missingVersion"));
        } else if (!version.equals(SAML2Constants.VERSION_2_0)) {
            throw new SAML2Exception(SAML2SDKUtils.bundle.getString(
            "incorrectVersion"));
        }
    }

   /* Validates the IssueInstant attribute in the SAML Response. */
    protected void validateIssueInstant(String issueInstantStr)
    throws SAML2Exception {
        if ((issueInstantStr == null || issueInstantStr.length() == 0)) {
            throw new SAML2Exception(
            SAML2SDKUtils.bundle.getString("missingIssueInstant"));
        } else {
            try {
                issueInstant = DateUtils.stringToDate(issueInstantStr);
            } catch (ParseException e) {
                SAML2SDKUtils.debug.message("Error parsing IssueInstant", e);
                throw new SAML2Exception(
                SAML2SDKUtils.bundle.getString("incorrectIssueInstant"));
            }
        }
    }

    /* Validates the Status element in the SAML Response. */
    protected void validateStatus()
    throws SAML2Exception {
        if (status == null) {
            throw new SAML2Exception(
            SAML2SDKUtils.bundle.getString("missingStatus"));
        }
    }

   /* Validates the required elements in the SAML Response. */
    protected void validateData() throws SAML2Exception {
        validateID(responseId);
        validateVersion(version);
        if (issueInstant == null) {
            throw new SAML2Exception(
            SAML2SDKUtils.bundle.getString("incorrectIssueInstant"));
        }
        validateIssueInstant(DateUtils.dateToString(issueInstant));
        validateStatus();
    }
}
/**
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2006 Sun Microsystems Inc. All Rights Reserved
 *
 * The contents of this file are subject to the terms
 * of the Common Development and Distribution License
 * (the License). You may not use this file except in
 * compliance with the License.
 *
 * You can obtain a copy of the License at
 * https://opensso.dev.java.net/public/CDDLv1.0.html or
 * opensso/legal/CDDLv1.0.txt
 * See the License for the specific language governing
 * permission and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL
 * Header Notice in each file and include the License file
 * at opensso/legal/CDDLv1.0.txt.
 * If applicable, add the following below the CDDL Header,
 * with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * $Id: package-info.java,v 1.4 2008/06/25 05:46:40 qcheng Exp $
 * Portions Copyrighted 2014 ForgeRock AS
 */

/**
 * Defines Federation Account Management API.
 *
 * @supported.api
 * @deprecated since 12.0.0
 */
package com.sun.identity.federation.accountmgmt;
/**
 * DO NOT ALTER OR REMOVE COPYRIGHT NOT


 bounds.contains(pt) {
            let osm_building = closest_bldg
                .closest_pt(Pt2D::from_gps(pt, bounds).unwrap(), Distance::meters(30.0))
                .map(|(b, _)| b);
            if let Some(b) = osm_building {
                metadata.insert(
                    b,
                    Parcel {
                        num_households,
                        num_employees,
                        offstreet_parking_spaces,
                    },
                );
            }
            result.insert(
                id,
                Endpoint {
                    pos: pt,
                    osm_building,
                },
            );
        }
    }
    Ok((result, metadata))
}

// From https://github.com/psrc/soundcast/wiki/Outputs#trip-file-_triptsv, opurp and dpurp
fn get_purpose(code: &str) -> Purpose {
    match code {
        "0.0" => Purpose::Home,
        "1.0" => Purpose::Work,
        "2.0" => Purpose::School,
        "3.0" => Purpose::Escort,
        "4.0" => Purpose::PersonalBusiness,
        "5.0" => Purpose::Shopping,
        "6.0" => Purpose::Meal,
        "7.0" => Purpose::Social,
        "8.0" => Purpose::Recreation,
        "9.0" => Purpose::Medical,
        "10.0" => Purpose::ParkAndRideTransfer,
        _ => panic!("Unknown opurp/dpurp {}", code),
    }
}

// From https://github.com/psrc/soundcast/wiki/Outputs#trip-file-_triptsv, mode
fn get_mode(code: &str) -> Option<Mode> {
    match code {
        "1.0" => Some(Mode::Walk),
        "2.0" => Some(Mode::Bike),
        "6.0" => Some(Mode::Transit),
        "3.0" | "4.0" | "5.0" => Some(Mode::Drive),
        _ => None,
    }
}
<reponame>AltF02/xv6<filename>drivers/src/io.rs
pub mod console;
<filename>src/bitmap/util.rs
#[inline]
pub fn split(value: u32) -> (u16, u16) {
    ((value >> 16) as u16, value as u16)
}

#[inline]
pub fn join(high: u16, low: u16) -> u32 {
    (u32::from(high) << 16) + u32::from(low)
}

#[cfg(test)]
mod test {
    use super::{ split, join };

    #[test]
    fn test_split_u32() {
        assert_eq!((0x0000u16, 0x0000u16), split(0x0000_0000u32));
        assert_eq!((0x0000u16, 0x0001u16), split(0x0000_0001u32));
        assert_eq!((0x0000u16, 0xFFFEu16), split(0x0000_FFFEu32));
        assert_eq!((0x0000u16, 0xFFFFu16), split(0x0000_FFFFu32));
        assert_eq!((0x0001u16, 0x0000u16), split(0x0001_0000u32));
        assert_eq!((0x0001u16, 0x0001u16), split(0x0001_0001u32));
        assert_eq!((0xFFFFu16, 0xFFFEu16), split(0xFFFF_FFFEu32));
        assert_eq!((0xFFFFu16, 0xFFFFu16), split(0xFFFF_FFFFu32));
    }

    #[test]
    fn test_join_u32() {
        assert_eq!(0x0000_0000u32, join(0x0000u16, 0x0000u16));
        assert_eq!(0x0000_0001u32, join(0x0000u16, 0x0001u16));
        assert_eq!(0x0000_FFFEu32, join(0x0000u16, 0xFFFEu16));
        assert_eq!


LIST_1",
        "PAGE_RECOMMEND_FEELING_PLAYLIST_LOCATION",
        "PAGE_RECOMMEND_MUSIC_FM_LIST",
        "PAGE_RECOMMEND_STYLE_PLAYLIST_2",
        "PAGE_RECOMMEND_REAL_TIME_INTEREST_RCMD",
        "PAGE_RECOMMEND_ARTIST_FM_LIST",
        "PAGE_RECOMMEND_PODCAST_ALBUM_COVER",
        "PAGE_RECOMMEND_PODCAST_MUSIC_RADIO",//音乐播客
        "PAGE_RECOMMEND_MONTH_YEAR_PLAYLIST",
        "PAGE_RECOMMEND_ARTIST_TREND",
        "PAGE_RECOMMEND_VIP_CARD",
        "PAGE_RECOMMEND_SCENE_PLAYLIST_LOCATION",
        "PAGE_RECOMMEND_NEW_SONG_AND_ALBUM",
        "PAGE_RECOMMEND_PODCAST_AUDIO_BOOK",
        "PAGE_RECOMMEND_PODCAST_RADIO_PROGRAM",
        "PAGE_RECOMMEND_BROADCAST",
        "PAGE_RECOMMEND_SPECIAL_ORIGIN_SONG_LOCATION"
    ),
    listOf(

        "PAGE_RECOMMEND_FIRM_PLAYLIST",
        "PAGE_RECOMMEND_COMBINATION",
        "PAGE_RECOMMEND_STYLE_PLAYLIST_1",
        "PAGE_RECOMMEND_FEELING_PLAYLIST_LOCATION",
        "PAGE_RECOMMEND_MUSIC_FM_LIST",
        "PAGE_RECOMMEND_STYLE_PLAYLIST_2",
        "PAGE_RECOMMEND_REAL_TIME_INTEREST_RCMD",
        "PAGE_RECOMMEND_ARTIST_FM_LIST",
        "PAGE_RECOMMEND_PODCAST_ALBUM_COVER",
        "PAGE_RECOMMEND_PODCAST_MUSIC_RADIO",
        "PAGE_RECOMMEND_MONTH_YEAR_PLAYLIST",
        "PAGE_RECOMMEND_ARTIST_TREND",
        "PAGE_RECOMMEND_VIP_CARD",
        "PAGE_RECOMMEND_SCENE_PLAYLIST_LOCATION",
        "PAGE_RECOMMEND_NEW_SONG_AND_ALBUM",
        "PAGE_RECOMMEND_PODCAST_AUDIO_BOOK",
        "PAGE_RECOMMEND_PODCAST_RADIO_PROGRAM",
        "PAGE_RECOMMEND_BROADCAST",
        "PAGE_RECOMMEND_SPECIAL_ORIGIN_SONG_LOCATION"
    ),
    listOf(
        "PAGE_RECOMMEND_ARTIST_FM_LIST",
        "PAGE_RECOMMEND_PODCAST_ALBUM_COVER",
        "PAGE_RECOMMEND_PODCAST_MUSIC_RADIO",
        "PAGE_RECOMMEND_MONTH_YEAR_PLAYLIST",
        "PAGE_RECOMMEND_ARTIST_TREND",
        "PAGE_RECOMMEND_VIP_CARD",
        "PAGE_RECOMMEND_SCENE_PLAYLIST_LOCATION",
        "PAGE_RECOMMEND_NEW_SONG_AND_ALBUM",
        "PAGE_RECOMMEND_PODCAST_AUDIO_BOOK",
        "PAGE_RECOMMEND_PODCAST_RADIO_PROGRAM",
        "PAGE_RECOMMEND_BROADCAST",
        "PAGE_RECOMMEND_SPECIAL_ORIGIN_SONG_LOCATION"
    )

)package com.ljyh.mei.data.model.qq.u
import com.google.gson.annotations.SerializedName

data class GetLyricData(
    @SerializedName("comm")
    val comm: Comm = Comm(),
    @SerializedName("music.musichallSong.PlayLyricInfo.GetPlayLyricInfo")
    val getPlayLyricInfo: GetPlayLyricInfo
){
    data class Comm(
        @SerializedName("_channelid")
        val channelid: String = "",
        @SerializedName("_os_version")
        val osVersion: String = "6.2.9200-2",
        @SerializedName("authst")
        val authst: String = "",
        @SerializedName("ct")
        val ct: String = "19",
        @SerializedName("cv")
        val cv: String = "1942",
        @SerializedName("patch")
        val patch: String = "118",


ret     $31, ($27)                   /* All synced up                */
.end srom_write_lcd

        .globl srom_write_word
        .set noat
        .text
        .align  4
        .ent srom_write_word
 #
 #
 #       enter with $16 the addr
 #       enter with $17 the data
srom_write_word:
iic_write_word:
	bsr	$27, srom_iic_wait_for_idle
	and     $16, 0xfe, $16
        stb     $16, 0($0)
        ldbu    $2, 0($1)
	bis     $31, 0xc5, $16
	bis	$31, $31, $31
	bis	$31, $31, $31
	bis	$31, $31, $31
	mb
        bis     $31, $31, $31
        bis     $31, $31, $31
        bis     $31, $31, $31

        stb     $16, 1($0)
        ldbu    $2, 0($1)
        bsr     $27, iic_wait_for_pin
        stb     $17, 0($0)
        ldbu    $2, 0($1)
        bsr     $27, iic_wait_for_pin
        bis     $31, 0xc3, $16
        stb     $16, 1($0)
        ldbu    $2, 0($1)
	ret	$31,  ($28)

.end srom_write_word

usdelay:
	lda	$3, 6667($31)
        mulq    $3, 16, $3
usdelay_init:
        rpcc    $2
        bis     $31, $31, $31
        bis     $31, $31, $31
        bis     $31, $31, $31
usdelay_loop:
        rpcc    $4
        subq    $4, $2, $4
        zapnot  $4, 0x0f, $4
        cmplt   $3, $4, $4
        beq     $4, usdelay_loop
	ret	$31,  ($28)

        .globl srom_access_lcd
        .set noat
        .text
        .align  4
        .ent srom_access_lcd
 #
 #
 #       enter with $16 control
 #       enter with $17 contrast | rs
srom_access_lcd:
	bis     $31, $17, $6
	bsr	$27, iic_set_addresses
	bis     $31, $16, $17
	bis	$31, 0x42, $16
	bsr	$28, srom_write_word
	bsr	$28, usdelay
	bis     $6, 0x60, $17
	bis	$31, 0x40, $16
	bsr	$28, srom_write_word
	bsr	$28, usdelay
	bis     $6, 0x40, $17
	bis	$31, 0x40, $16
	bsr	$28, srom_write_word
	bsr	$28, usdelay
	bis     $31, $16, $17
	bis     $6, 0x60, $17
	bis	$31, 0x40, $16
	bsr	$28, srom_write_word
	bsr	$28, usdelay
	ret	$31,  ($26)

.end srom_access_lcd

        .globl srom_init_lcd
        .set noat
        .text
        .align  4
        .ent srom_init_lcd
 #
 #
srom_init_lcd:
	bis     $31, $26, $7
	ldah	$0, 0x400f($31)
	lda     $0, 0xf000($0)
	sll     $0, 13, $0
	lda     $0, 0x2847($0)
	bis	$31, 0xe0, $1
	stb	$1, ($0)

	bsr	$27, iic


2 = [0,0,0,0,0,0,0,0]
checkpotreading3 = [0,0,0,0,0,0,0,0]
displaytext = ""
pot = -1
displayupdated = False

def potDisplay(pot):
    # Some modes return a hex display, some decimal
    # Pot (0-7) -> MIDI TG (1-8)
    tg = pot+1
    if uimode[pot] == 1:
        return "%02d" % getMidiVolumeDisplay(tg)
    elif uimode[pot] == 2:
        return "%02x" % getMidiBankDisplay(tg)
    elif uimode[pot] == 3:
        return "%02x" % getMidiDetuneDisplay(tg)
    else:
        return "%02d" % getMidiVoiceDisplay(tg)

def scanPots():
    global pot, displayupdated, potreading, lastpotreading, checkpotreading, checkpotreading2, checkreading3, displaytext
    # Read pots
    pot = pot+1
    if pot == 8:
        # Update display if required
        if (displayupdated):
            displaytext = potDisplay(0)+potDisplay(1)+potDisplay(2)+potDisplay(3)+\
                          potDisplay(4)+potDisplay(5)+potDisplay(6)+potDisplay(7)
        return
    elif pot == 9:
        if (displayupdated):
            display.text(displaytext, dots)
        return
    elif pot > 9:
        #print (potreading, potdivisor)
        # Reset
        pot = 0
        displayupdated = False

    # NB: pots are reversed in the circuit...
    # Also: pots scaled to 0..127 by default
    potreading[pot] = 127 - int(pots.smoothread(pot)/8)

    if potreading[pot] == checkpotreading[pot] and\
       potreading[pot] == checkpotreading2[pot] and\
       potreading[pot] == checkpotreading3[pot]:
        # Reading is steady...
        if potreading[pot] != lastpotreading[pot]:
            # Reading has changed and is steady so act on it
            displayupdated = True
            lastpotreading[pot] = potreading[pot]

            # Action depends on uimode[]
            #print (pot, "->", potreading[pot])

            # Pot (0-7) -> MIDI TG (1-8)
            tg = pot+1
            if uimode[pot] == 1:
                # Volume mode:
                # Value (0-1023) -> MIDI data (0-127)
                setMidiVolume(tg, potreading[pot])
                injectMidiCC(tg, MIDI_CC_VOLUME, getMidiVolume(tg))
            elif uimode[pot] == 2:
                # Bank Select:
                # Value (0-1023) -> MIDI data (0-7)
                setMidiBank(tg, potreading[pot])
                injectMidiCC(tg, MIDI_CC_BANKSEL, getMidiBank(tg))
            elif uimode[pot] == 3:
                # Bank Select:
                # Value (0-1023) -> Detune (-99 to 99) -> MIDI data (0-127)
                setMidiDetune(tg, potreading[pot])
                injectMidiCC(tg, MIDI_CC_DETUNE, getMidiDetune(tg))
            else:
                # Normal mode: MIDI Voice/Program Change
                # Value (0-1023) -> MIDI data (0-31)
                setMidiVoice(tg, potreading[pot])
                injectMidiPC(tg, getMidiVoice(tg))

    # Sort of "debounce" the readings
    checkpotreading3[pot] = checkpotreading2[pot]
    checkpotreading2[pot] = checkpotreading[pot]
    checkpotreading[pot] = potreading[pot]

# -----------------------------------------------
#
#  Main Loop!
#
# -----------------------------------------------

#  NB: LED and 7Seg Displays are sub-scheduled into the
#      switch and pot scanning to split up the overheads
#      over several scans and seperate out the sensing
#      from the displaying.

toggle = False
while True:
    if (uart0.any()):
        md[0].read(uart0.read(1)[0])
    if (uart1.any()):
        md[1].read(uart1.read(1)[0])

    # Alternate scanning the switches (and outputing LEDS) and pots (and updating the 7-segments)
    if toggle:
        scanSwitches()
        toggle = False
    else:
        scanPots()
        toggle = True


    );
    if (shipperNameInfo) {
      shipperName = shipperNameInfo.groups.shipperName
        .replace(/\n/g, ' ')
        .trim();
    }

    return shipperName;
  }

  public getShipperPhone(): string | null {
    let shipperPhone = null;
    const shipperPhoneInfo = /^(Contact:.*)(Phone:\s)(?<phone>.*?)\nFax/gms.exec(
      this.templateText,
    );
    if (shipperPhoneInfo) {
      shipperPhone = shipperPhoneInfo.groups.phone.replace(/\n/g, ' ').trim();
    }

    return shipperPhone;
  }

  public getPaymentTerms(): string | null {
    let paymentTerms = null;
    const paymentTermsInfo = /owes Carrier: \D(?<price>(\d+|\.+|,+)+)(?<paymentTerms>.*?\n\*)/gms.exec(
      this.templateText,
    );
    if (paymentTermsInfo) {
      paymentTerms = paymentTermsInfo.groups.paymentTerms
        .replace(/\n/g, ' ')
        .trim()
        .slice(0, -1)
        .trim();
    }

    return paymentTerms;
  }
}
import { PropertySpecs } from '../interfaces/helpers';

const extractNumbersOfString = (str: string): number => {
  if (!str) return null;

  const matched = str.match(/\d+/g)

  if (!matched) return null;

  const formattedMatch = str.match(/\d+/g).map(Number).join('');
  return Number(formattedMatch);
}

export const extractSpecs = (itemAttrs: string): PropertySpecs => {
  const specs = itemAttrs.split('|');

  return {
    size: extractNumbersOfString(specs.find(spec => spec.includes('m²'))),
    rooms: extractNumbersOfString(specs.find(spec => spec.includes('dormitorio'))),
    bathrooms: extractNumbersOfString(specs.find(spec => spec.includes('baño'))),
  }
}

export const splitSeparatedFields = (fields: string, separator = ','): string[] => {
  return fields
    .split(separator)
    .map(field => field.trim())
    .filter(field => !!field);
}
import { JsonValue } from './constants'

export const stringifyJSON = (obj: JsonValue) => JSON.stringify(obj, null, 2)

export function parseJSON(str: string) {
  try {
    return JSON.parse(str)
  } catch (e) {
    return str
  }
}
import { Resolver, Query, ResolveField, Args, Int, Mutation, InputType, Field, Parent } from '@nestjs/graphql';
import { Transporteur } from './transporteur.entity';
import { Vehicule } from '../vehicule/vehicule.entity';

@Resolver(of => Transporteur)
export class TransporteurResolver {

  constructor() {}

  @Query(returns => Transporteur)
  async getTransporteur(@Args('id', { type: () => Int }) id: number) {
    return await Transporteur.findOne(id);
  }

  @Query(returns => [Transporteur])
  async getTransporteurs() {
    return await Transporteur.createQueryBuilder().getMany();

  }

  @Query(returns => [Transporteur])
  async getOneTransporteur(@Args('id', {type: () => Int!} ) id: number) {
    return await Transporteur.findOne(id);
  }

  @Mutation(returns => Transporteur)
  async deleteTransporteur(@Args('id', {type: () => Int}) id: number) {

    let transporteur = Transporteur.findOne(id);

    (await transporteur).remove();

    return transporteur;
  }

  @Mutation(returns => Transporteur)
  async updateTransporteur(@Args('transporteurInput') transporteurInput: Transporteur) {
    let transporteur = await Transporteur.findOne(transporteurInput.id);


          display: "Thursday"
            },
            {
                code: "fri",
                display: "Friday"
            },
            {
                code: "sat",
                display: "Saturday"
            },
            {
                code: "sun",
                display: "Sunday"
            }
        ]
    }
];

export default Daysofweek;
// create new TrustRelation with RemoteIdp and picks default Sso

import { RemoteIdp } from '@sp-proxy/entities/RemoteIdp'
import { TrustRelation } from '@sp-proxy/entities/TrustRelation'
import { pickDefaultSso } from '@sp-proxy/use-cases/helpers/pickDefaultSso'
import { IFactory } from '@sp-proxy/use-cases/protocols/IFactory'

export interface TrustRelationWithDefaultsParams {
  remoteIdp: RemoteIdp
  trId?: string
}

/**
 * Factory class to create Trust Relation isntance from remoteIdp
 * and choose default SingleSignOnService according to application rules
 * @export
 * @class TrustRelationWithDefaultFactory
 * @implements {IFactory<TrustRelationWithDefaultsParams, TrustRelation>}
 */
export class TrustRelationWithDefaultFactory
  implements IFactory<TrustRelationWithDefaultsParams, TrustRelation>
{
  /**
   * Create TrustRelation instance and assign default SingleSignOnService
   *
   * @param {TrustRelationWithDefaultsParams} params
   * @param {string} [trId]
   * @return {*}  {Promise<TrustRelation>}
   * @memberof TrustRelationWithDefaultFactory
   */
  async make(
    params: TrustRelationWithDefaultsParams,
    trId?: string
  ): Promise<TrustRelation> {
    return new TrustRelation(
      {
        remoteIdp: params.remoteIdp,
        singleSignOnService: pickDefaultSso(
          params.remoteIdp.props.supportedSingleSignOnServices
        )
      },
      trId
    )
  }
}
import { User } from "../../entities/User";

export interface GetUserServiceModel {
  getUser: () => Promise<User>;
}

export class GetUserInteractor {
  private getUserService: GetUserServiceModel;

  constructor(getUserService: GetUserServiceModel) {
    this.getUserService = getUserService
  }

  async getUser(): Promise<User> {
    return this.getUserService.getUser();
  }
}export enum Act {
  ActI = 0,
  ActII = 1,
  ActIII = 2,
  ActIV = 3,
  ActV = 4,
}

/** LevelCode => Act @see ActUtil.fromLevel */
export const ActLevels = {
  ActI: 40,
  ActII: 75,
  ActIII: 103,
  ActIV: 109,
  ActV: 142,
};

export const ActUtil = {
  fromLevel(code: number): Act {
    if (code < ActLevels.ActI) return Act.ActI;
    if (code < ActLevels.ActII) return Act.ActII;
    if (code < ActLevels.ActIII) return Act.ActIII;
    if (code < ActLevels.ActIV) return Act.ActIV;
    if (code < ActLevels.ActV) return Act.ActV;
    return Act.ActV;
  },

  fromString(f?: string | null): Act | null {
    if (f == null) return null;
    const num = Number(f);
    if (!isNaN(num)) {
      if (num in Act) return num;
      return null;
    }
    switch (f.toLowerCase()) {
      case 'acti':
        return Act.ActI;
      case 'actii':
        return Act.ActII;
      case 'actiii':
        return Act.ActIII;
      case 'activ':
        return Act.ActIV;


 UF2_BLOCKS_PER_FAT_BLOCK: u32 = (BLOCK_SIZE / UF2_BLOCK_SIZE) as u32;
const NUM_FAT_BLOCKS: u32 = 8000;
const RESERVED_SECTORS: u32 = 1;
const ROOT_DIR_SECTORS: u32 = 4;
const SECTORS_PER_FAT: u32 = (NUM_FAT_BLOCKS * 2 + 511) / 512;
const START_FAT0: u32 = RESERVED_SECTORS;
const START_FAT1: u32 = START_FAT0 + SECTORS_PER_FAT;
const START_ROOTDIR: u32 = START_FAT1 + SECTORS_PER_FAT;
const START_CLUSTERS: u32 = START_ROOTDIR + ROOT_DIR_SECTORS;
const UF2_SIZE: u32 = 0x10000 * 2;
const UF2_SECTORS: u32 = UF2_SIZE / (BLOCK_SIZE as u32);

const RESTART_DELAY_MS: u32 = 200;

// Magic tokens to change the behaviour on boot up
// I don't know why they are u32 instead of just u16 that would fit in a single backup register
// just copied from dapboot.c for now
const CMD_BOOT: u32 = 0x544F4F42;
const CMD_APP: u32 = 0x3F82722A;
const BACKUP_REGISTER: usize = 0;

const ASCII_SPACE: u8 = 0x20;

fn read_u32_backup_register(backup_domain: &BackupDomain, register: usize) -> u32 {
      (backup_domain.read_data_register_low(register * 2 + 1) as u32) << 16
    | (backup_domain.read_data_register_low(register * 2) as u32)
}

fn write_u32_backup_register(backup_domain: &BackupDomain, register: usize, value: u32) {
    backup_domain.write_data_register_low(register * 2 + 1, (value >> 16) as u16);
    backup_domain.write_data_register_low(register * 2, (value & 0x0000FFFF) as u16);
}

#[derive(Clone, Copy, Default, Packed)]
#[packed(little_endian, lsb0)]
pub struct DirectoryEntry {
    #[pkd(7, 0, 0, 10)]
    pub name: [u8; 11],
    /*
        pub name: [u8; 8],
        pub ext: [u8; 3],
    */
    #[pkd(7, 0, 11, 11)]
    pub attrs: u8,

    #[pkd(7, 0, 12, 12)]
    _reserved: u8,

    #[pkd(7, 0, 13, 13)]
    pub create_time_fine: u8,

    #[pkd(7, 0, 14, 15)]
    pub create_time: u16,

    #[pkd(7, 0, 16, 17)]
    pub create_date: u16,

    #[pkd(7, 0, 18, 19)]
    pub last_access_date: u16,

    #[pkd(7, 0, 20, 21)]
    pub high_start_cluster: u16,

    #[pkd(7, 0, 22, 23)]
    pub update_time: u16,

    #[pkd(7, 0, 24, 25)]
    pub update_date: u16,

    #[pkd(7, 0, 26, 27)]
    pub start_cluster: u16,

    #[pkd(7, 0, 28, 31)]
    pub size: u32,
}

pub enum FatFileContent {
    Static([u8; 255]),
    Uf2,
}

pub struct FatFile {
    pub name: [u8; 11],
    pub content: FatFileContent,
}

impl FatFile {
    fn with_content<N: AsRef<[u8]>, T


    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("invalid UNIX timestamp value")
    }
}

/// Signifies the failure to parse the `Timestamp` from an RFC 3339 string.
#[derive(Debug)]
pub struct ParseError(InnerError);

impl std::error::Error for ParseError {}

impl fmt::Display for ParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.0, f)
    }
}

impl FromStr for Timestamp {
    type Err = ParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Timestamp::parse(s)
    }
}

impl From<String> for Timestamp {
    /// Parses an RFC 3339 date and time string such as `2016-04-30T11:18:25.796Z`.
    ///
    /// Panics on invalid value.
    fn from(s: String) -> Self {
        #[allow(clippy::unwrap_used)]
        Timestamp::parse(&s).unwrap()
    }
}

impl<'a> From<&'a str> for Timestamp {
    /// Parses an RFC 3339 date and time string such as `2016-04-30T11:18:25.796Z`.
    ///
    /// Panics on invalid value.
    fn from(s: &'a str) -> Self {
        #[allow(clippy::unwrap_used)]
        Timestamp::parse(s).unwrap()
    }
}

impl From<&Timestamp> for Timestamp {
    fn from(ts: &Timestamp) -> Self {
        *ts
    }
}

#[cfg(test)]
mod tests {
    use super::Timestamp;

    #[test]
    fn from_unix_timestamp() {
        let timestamp = Timestamp::from_unix_timestamp(1462015105).unwrap();
        assert_eq!(timestamp.unix_timestamp(), 1462015105);
        if cfg!(all(feature = "chrono", not(feature = "time"))) {
            assert_eq!(timestamp.to_string(), "2016-04-30T11:18:25.000Z");
        } else {
            assert_eq!(timestamp.to_string(), "2016-04-30T11:18:25Z");
        }
    }
}
use std::error::Error;
use std::fmt::{Debug, Formatter};
use std::hash::Hash;

use sic_core::image::FilterType;

#[derive(Clone, Copy)]
pub struct FilterTypeWrap {
    inner: FilterType,
}

impl FilterTypeWrap {
    pub fn new(with: FilterType) -> Self {
        Self { inner: with }
    }
}

impl PartialEq<FilterTypeWrap> for FilterTypeWrap {
    fn eq(&self, other: &FilterTypeWrap) -> bool {
        std::mem::discriminant(&self.inner) == std::mem::discriminant(&other.inner)
    }
}

impl Eq for FilterTypeWrap {}

impl Hash for FilterTypeWrap {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        std::mem::discriminant(&self.inner).hash(state)
    }
}

impl Debug for FilterTypeWrap {
    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {
        let msg = match self.inner {
            FilterType::CatmullRom => "image::FilterType::CatmullRom (Wrapper)",
            FilterType::Gaussian => "image::FilterType::Gaussian (Wrapper)",
            FilterType::Lanczos3 => "image::FilterType::Lanczos3 (Wrapper)",
            FilterType::Nearest => "image::FilterType::Nearest (Wrapper)",
            FilterType::Triangle => "image::FilterType::Triangle (Wrapper)",
        };

        f.write_str(msg)
    }
}

impl From<FilterTypeWrap> for FilterType {
    fn from(wrap: FilterTypeWrap) -> Self {


g-boot/sys/comment/addText

/jeecg-boot/sys/comment/delete

/jeecg-boot/sys/comment/deleteBatch

/jeecg-boot/sys/comment/deleteOne

/jeecg-boot/sys/comment/edit

/jeecg-boot/sys/comment/fileList

/jeecg-boot/sys/comment/list

/jeecg-boot/sys/comment/listByForm

/jeecg-boot/sys/comment/queryById

/jeecg-boot/sys/dataSource/add

/jeecg-boot/sys/dataSource/delete

/jeecg-boot/sys/dataSource/deleteBatch

/jeecg-boot/sys/dataSource/edit

/jeecg-boot/sys/dataSource/list

/jeecg-boot/sys/dataSource/queryById

/jeecg-boot/sys/dictItem/dictItemCheck

/jeecg-boot/sys/duplicate/check

/jeecg-boot/sys/files/add

/jeecg-boot/sys/files/delete

/jeecg-boot/sys/files/deleteBatch

/jeecg-boot/sys/files/edit

/jeecg-boot/sys/files/list

/jeecg-boot/sys/files/queryById

/jeecg-boot/sys/fillRule/add

/jeecg-boot/sys/fillRule/delete

/jeecg-boot/sys/fillRule/deleteBatch

/jeecg-boot/sys/fillRule/edit

/jeecg-boot/sys/fillRule/list

/jeecg-boot/sys/fillRule/queryById

/jeecg-boot/sys/formFile/add

/jeecg-boot/sys/formFile/delete

/jeecg-boot/sys/formFile/deleteBatch

/jeecg-boot/sys/formFile/edit

/jeecg-boot/sys/formFile/list

/jeecg-boot/sys/formFile/queryById

/jeecg-boot/sys/position/add

/jeecg-boot/sys/position/delete

/jeecg-boot/sys/position/deleteBatch

/jeecg-boot/sys/position/edit

/jeecg-boot/sys/position/list

/jeecg-boot/sys/position/queryByCode

/jeecg-boot/sys/position/queryById

/jeecg-boot/sys/quartzJob/pause

/jeecg-boot/sys/quartzJob/resume

/jeecg-boot/sys/randomImage/

/jeecg-boot/sys/sysDepartPermission/add

/jeecg-boot/sys/sysDepartPermission/delete

/jeecg-boot/sys/sysDepartPermission/deleteBatch

/jeecg-boot/sys/sysDepartPermission/edit

/jeecg-boot/sys/sysDepartPermission/list

/jeecg-boot/sys/sysDepartPermission/queryById

/jeecg-b


oken: Token;
    getLastToken(filter?: (token: Token) => boolean): Token;
  }
};

export default parser;

interface Ast_$EOF_Node_ extends BaseTokenNode {
      token:"$EOF";
      parent:AstSymbolNode;
    }
export type Ast_$EOF_Node = Ast_$EOF_Node_;
interface Ast_$UNKNOWN_Node_ extends BaseTokenNode {
      token:"$UNKNOWN";
      parent:AstSymbolNode;
    }
export type Ast_$UNKNOWN_Node = Ast_$UNKNOWN_Node_;
interface Ast_TOKEN_0_Node_ extends BaseTokenNode {
            token:"(";
            parent:Ast_Exp_Node_0;
          }
export type Ast_TOKEN_0_Node = Ast_TOKEN_0_Node_;
interface Ast_TOKEN_1_Node_ extends BaseTokenNode {
            token:")";
            parent:Ast_Exp_Node_0;
          }
export type Ast_TOKEN_1_Node = Ast_TOKEN_1_Node_;
interface Ast_Exp_Node_0_ extends BaseSymbolNode {
        symbol:"exp";

        children:[Ast_TOKEN_0_Node,Ast_Exp_Node,Ast_TOKEN_1_Node];
        parent:Ast_Exp_Node_0 | Ast_Exp_Node_1 | Ast_Exp_Node_2 | Ast_Exp_Node_3 | Ast_Exp_Node_4 | Ast_Exp_Node_5 | Ast_Exp_Node_6;
      }
type Ast_Exp_Node_0 = Ast_Exp_Node_0_;
interface Ast_TOKEN_2_Node_ extends BaseTokenNode {
            token:"+";
            parent:Ast_Exp_Node_1;
          }
export type Ast_TOKEN_2_Node = Ast_TOKEN_2_Node_;
interface Ast_Exp_Node_1_ extends BaseSymbolNode {
        symbol:"exp";

        children:[Ast_Exp_Node,Ast_TOKEN_2_Node,Ast_Exp_Node];
        parent:Ast_Exp_Node_0 | Ast_Exp_Node_1 | Ast_Exp_Node_2 | Ast_Exp_Node_3 | Ast_Exp_Node_4 | Ast_Exp_Node_5 | Ast_Exp_Node_6;
      }
type Ast_Exp_Node_1 = Ast_Exp_Node_1_;
interface Ast_TOKEN_3_Node_ extends BaseTokenNode {
            token:"-";
            parent:Ast_Exp_Node_2 | Ast_Exp_Node_5;
          }
export type Ast_TOKEN_3_Node = Ast_TOKEN_3_Node_;
interface Ast_Exp_Node_2_ extends BaseSymbolNode {
        symbol:"exp";

        children:[Ast_Exp_Node,Ast_TOKEN_3_Node,Ast_Exp_Node];
        parent:Ast_Exp_Node_0 | Ast_Exp_Node_1 | Ast_Exp_Node_2 | Ast_Exp_Node_3 | Ast_Exp_Node_4 | Ast_Exp_Node_5 | Ast_Exp_Node_6;
      }
type Ast_Exp_Node_2 = Ast_Exp_Node_2_;
interface Ast_TOKEN_4_Node_ extends BaseTokenNode {
            token:"*";
            parent:Ast_Exp_Node_3;
          }
export type Ast_TOKEN_4_Node = Ast_TOKEN_4_Node_;
interface Ast_Exp_Node_3_ extends BaseSymbolNode {
        symbol:"exp";

        children:[Ast_Exp_Node,Ast_TOKEN_4_Node,Ast_Exp_Node];
        parent:Ast_Exp_Node_0 | Ast_Exp_Node_1 | Ast_Exp_Node_2 | Ast_Exp_Node_3 | Ast_Exp_Node_4 | Ast_Exp_Node_5 | Ast_Exp_Node_6;
      }
type Ast_Exp_Node_3 = Ast_Exp_Node_3_;
interface Ast_TOKEN_5_Node_ extends BaseTokenNode {
            token:"/";
            parent:Ast_Exp_Node_4;
          }
export type Ast_TOKEN_5_Node = Ast_TOKEN_5_Node_;
interface Ast_Exp_Node_4_ extends BaseSymbolNode {


Bof, ça ne va pas", "Je ne sais pas"};
        std::string answerAdel = adel.getAnswer(options);
        if (answerAdel == "1")
        {
            adel.talk("Je vais super bien !");
            hiloul.talk("Tant mieux, je suis heureuse !");
            // Sort de la boucle en cas de réponse valide
            break;
        }
        else if (answerAdel == "2")
        {
            adel.talk("Bof, ça ne va pas");
            hiloul.talk("Oh non que puis-je faire pour toi ?");
            break;
        }
        else
        {
            hiloul.talk("Mauvaise reponse: Coucou ! Comment tu vas ?");
        }
    }

    // Ajouter une ligne vide
    std::cout << std::endl
              << std::endl;

    // 2ème question
    while (true)
    {
        hiloul.talk("Est-ce que tu me trouves jolie aujourd'hui ?");

        // Choisir sa réponse
        std::vector<std::string> options2 = {"Oui youhou !", "Non beurk !", "autre"};
        std::string answerAdel2 = adel.getAnswer(options2);
        if (answerAdel2 == "1")
        {
            adel.talk("Oui tu est très belle !");
            hiloul.talk("Merci beaucoup ca me fait plaisir !");
            adel.adjustPointsRelationship(1);
            // break;
        }
        else if (answerAdel2 == "2")
        {
            adel.talk("Non beurk !");
            hiloul.talk("Oh ok tant pis...");
            adel.adjustPointsRelationship(-1);
            // break;
        }
        else
        {
            hiloul.talk("Pas compris ta réponse tu me trouvais jolie ? ?");
        }
        // Correction ici : ajout de la virgule
        hiloul.talk("Points de relation avec Adel: " +
                    std::to_string(adel.pointsRelationship));
        break;
    }

    // Ajouter une ligne vide
    std::cout << std::endl
              << std::endl;

    // Troisième question
    while (true)
    {
        hiloul.talk("Est-ce que tu veux jouer ?");

        // Choisir sa réponse
        std::vector<std::string> options3 = {"Oui je veux jouer !", "Non merci !", "je ne sais pas"};
        std::string answerAdel3 = adel.getAnswer(options3);
        if (answerAdel3 == "1")
        {
            // Lancer le mini-jeu de Pierre-Papier-Ciseaux
            playRockPaperScissors(hiloul, adel);
        }
        else if (answerAdel3 == "2")
        {
            adel.talk("Non merci !");
            hiloul.talk("Oh ok tant pis...");
            adel.adjustPointsRelationship(-1);
            break;
        }
        else
        {
            hiloul.talk("Pas compris ta réponse tu veux jouer ?");
        }
    }

    // Je met ca pour tester le programme.exe sinon disparait hors de while
#ifdef _WIN32
    Sleep(5000); // Délai en millisecondes sur Windows
#endif
    return 0;
}
#ifndef PY_MODULE_CPP
#define PY_MODULE_CPP

#include "greenlet_internal.hpp"

#include "TGreenletGlobals.cpp"
#include "TMainGreenlet.cpp"
#include "TThreadStateDestroy.cpp"

using greenlet::LockGuard;
using greenlet::ThreadState;

#ifdef __clang__
#    pragma clang diagnostic push
#    pragma clang diagnostic ignored "-Wunused-function"
#    pragma clang diagnostic ignored "-Wunused-variable"
#endif

PyDoc_STRVAR(mod_getcurrent_doc,
             "getcurrent


If at least 2 adjacent tiles are blocked consider it a corner
            for (var i = 0; i < 4; i++)
            {
                var dir = (Direction) (i * 2);
                blocked = HasWall(tile + dir.ToIntVec());

                if (!blocked)
                    continue;

                var nextDir = (Direction) ((i + 1) * 2 % 8);
                blocked = HasWall(tile + nextDir.ToIntVec());

                if (!blocked)
                    continue;

                if (random.Prob(gen.Chance))
                {
                    var coords = _maps.GridTileToLocal(_gridUid, _grid, tile);
                    var protos = _entTable.GetSpawns(contentsTable, random);
                    _entManager.SpawnEntitiesAttachedTo(coords, protos);
                }

                break;
            }
        }
    }
}


Location list end address (*.LLST37)
	.value	0x1	# Location expression size
	.byte	0x51	# DW_OP_reg1
	.quad	.LVL57-1	# Location list begin address (*.LLST37)
	.quad	.LFE15	# Location list end address (*.LLST37)
	.value	0x4	# Location expression size
	.byte	0xf3	# DW_OP_GNU_entry_value
	.uleb128 0x1
	.byte	0x51	# DW_OP_reg1
	.byte	0x9f	# DW_OP_stack_value
	.quad	0	# Location list terminator begin (*.LLST37)
	.quad	0	# Location list terminator end (*.LLST37)
.LLST38:
	.quad	.LVL55	# Location list begin address (*.LLST38)
	.quad	.LVL57-1	# Location list end address (*.LLST38)
	.value	0x1	# Location expression size
	.byte	0x52	# DW_OP_reg2
	.quad	.LVL57-1	# Location list begin address (*.LLST38)
	.quad	.LFE15	# Location list end address (*.LLST38)
	.value	0x4	# Location expression size
	.byte	0xf3	# DW_OP_GNU_entry_value
	.uleb128 0x1
	.byte	0x52	# DW_OP_reg2
	.byte	0x9f	# DW_OP_stack_value
	.quad	0	# Location list terminator begin (*.LLST38)
	.quad	0	# Location list terminator end (*.LLST38)
.LLST39:
	.quad	.LVL55	# Location list begin address (*.LLST39)
	.quad	.LVL57-1	# Location list end address (*.LLST39)
	.value	0x1	# Location expression size
	.byte	0x58	# DW_OP_reg8
	.quad	.LVL57-1	# Location list begin address (*.LLST39)
	.quad	.LFE15	# Location list end address (*.LLST39)
	.value	0x4	# Location expression size
	.byte	0xf3	# DW_OP_GNU_entry_value
	.uleb128 0x1
	.byte	0x58	# DW_OP_reg8
	.byte	0x9f	# DW_OP_stack_value
	.quad	0	# Location list terminator begin (*.LLST39)
	.quad	0	# Location list terminator end (*.LLST39)
.LLST40:
	.quad	.LVL55	# Location list begin address (*.LLST40)
	.quad	.LVL57-1	# Location list end address (*.LLST40)
	.value	0x1	# Location expression size
	.byte	0x59	# DW_OP_reg9
	.quad	.LVL57-1	# Location list begin address (*.LLST40)
	.quad	.LFE15	# Location list end address (*.LLST40)
	.value	0x4	# Location expression size
	.byte	0xf3	# DW_OP_GNU_entry_value
	.uleb128 0x1
	.byte	0x59	# DW_OP_reg9
	.byte	0x9f	# DW_OP_stack_value
	.quad	0	# Location list terminator begin (*.LLST40)
	.quad	0	# Location list terminator end (*.LLST40)
.LLST41:
	.quad	.LVL55	# Location list begin address (*.LLST41)
	.quad	.LVL57-1	# Location list end address (*.LLST41)
	.value	0x3	# Location expression size
	.byte	0x91	# DW_OP_fbreg
	.sleb128 0
	.byte	0x6	# DW_OP_deref
	.quad	0	# Location li


vement = 0;

	if (activeReceiver != nullptr && activeReceiver->MousePress(x, y, button))
		return;

	if (inMapDrawer != nullptr && inMapDrawer->IsDrawMode()) {
		inMapDrawer->MousePress(x, y, button);
		return;
	}

	// limited receivers for MMB
	if (button == SDL_BUTTON_MIDDLE) {
		if (!locked) {
			if (luaInputReceiver->MousePress(x, y, button)) {
				activeReceiver = luaInputReceiver;
				return;
			}
			if ((minimap != nullptr) && minimap->FullProxy()) {
				if (minimap->MousePress(x, y, button)) {
					activeReceiver = minimap;
					return;
				}
			}
		}
		return;
	}

	if (luaInputReceiver->MousePress(x, y, button)) {
		if (activeReceiver == nullptr)
			activeReceiver = luaInputReceiver;
		return;
	}

	if (game != nullptr && !game->hideInterface) {
		for (CInputReceiver* recv: CInputReceiver::GetReceivers()) {
			if (recv != nullptr && recv->MousePress(x, y, button)) {
				if (activeReceiver == nullptr)
					activeReceiver = recv;

				break;
			}
		}

		return;
	}

	if (guihandler != nullptr && guihandler->MousePress(x, y, button)) {
		if (activeReceiver == nullptr)
			activeReceiver = guihandler; // for default (rmb) commands
	}
}

/**
 * GetSelectionBoxCoeff
 *  returns the topright & bottomleft corner positions of the SelectionBox in (cam->right, cam->up)-space
 */
void CMouseHandler::GetSelectionBoxCoeff(
	const float3& pos1,
	const float3& dir1,
	const float3& pos2,
	const float3& dir2,
	float2& topright,
	float2& bttmleft
) {
	const float maxDist = camera->GetFarPlaneDist() * 1.4f;

	float pos1Dist = CGround::LineGroundCol(pos1, pos1 + dir1 * maxDist, false);
	float pos2Dist = CGround::LineGroundCol(pos2, pos2 + dir2 * maxDist, false);

	if (pos1Dist < 0.0f)
		pos1Dist = maxDist;
	if (pos2Dist < 0.0f)
		pos2Dist = maxDist;

	const float3 gpos1 = pos1 + dir1 * pos1Dist;
	const float3 gpos2 = pos2 + dir2 * pos2Dist;

	const float3 cdir1 = (gpos1 - camera->GetPos()).ANormalize();
	const float3 cdir2 = (gpos2 - camera->GetPos()).ANormalize();

	float cdir1_fw = cdir1.dot(camera->GetDir());
	float cdir2_fw = cdir2.dot(camera->GetDir());

	// prevent DivByZero
	cdir1_fw = std::max(std::fabs(cdir1_fw), 0.001f) * std::copysign(1.0f, cdir1_fw);
	cdir2_fw = std::max(std::fabs(cdir2_fw), 0.001f) * std::copysign(1.0f, cdir2_fw);

	// one corner of the rectangle
	topright.x = cdir1.dot(camera->GetRight()) / cdir1_fw;
	topright.y = cdir1.dot(camera->GetUp())    / cdir1_fw;

	// opposite corner
	bttmleft.x = cdir2.dot(camera->GetRight()) / cdir2_fw;
	bttmleft.y = cdir2.dot(camera->GetUp())    / cdir2_fw;

	// sort coeff so topright really is the topright corner
	if (topright.x < bttmleft.x) std::swap(topright.x, bttmleft.x);
	if (topright.y < bttmleft.y) std::swap(topright.y, bttmleft.y);
}

void CMouseHandler::MouseRelease(int x, int y, int button)
{
	const CUnit *_lastClicked = lastClicked;


delete Kb.transitionend.transition);var jh=hd("animationend"),kh=hd("animationiteration"),lh=hd("animationstart"),mh=hd("transitionend"),
fh=new Map,$i="abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");
(function(){for(var a=0;a<$i.length;a++){var b=$i[a],c=b.toLowerCase();b=b[0].toUpperCase()+b.slice(1);$a(c,"on"+b)}$a(jh,"onAnimationEnd");$a(kh,"onAnimationIteration");$a(lh,"onAnimationStart");$a("dblclick","onDoubleClick");$a("focusin","onFocus");$a("focusout","onBlur");$a(mh,"onTransitionEnd")})();Ab("onMouseEnter",["mouseout","mouseover"]);Ab("onMouseLeave",["mouseout","mouseover"]);Ab("onPointerEnter",["pointerout","pointerover"]);Ab("onPointerLeave",["pointerout","pointerover"]);nb("onChange",
"change click focusin focusout input keydown keyup selectionchange".split(" "));nb("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" "));nb("onBeforeInput",["compositionend","keypress","textInput","paste"]);nb("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" "));nb("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" "));nb("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));
var Ec="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),Vj=new Set("cancel close invalid load scroll toggle".split(" ").concat(Ec)),id="_reactListening"+Math.random().toString(36).slice(2),hk=/\r\n?/g,ik=/\u0000|\uFFFD/g,Jf=null,Kf=null,Rf="function"===typeof setTimeout?setTimeout:void 0,Ok="function"===typeof clearTimeout?
clearTimeout:void 0,aj="function"===typeof Promise?Promise:void 0,Kk="function"===typeof queueMicrotask?queueMicrotask:"undefined"!==typeof aj?function(a){return aj.resolve(null).then(a).catch(jk)}:Rf,Zb=Math.random().toString(36).slice(2),Da="__reactFiber$"+Zb,uc="__reactProps$


         let (finished, _, left) = futures::future::select_all(pending).await;
                pending = left;

                let (node, result) = finished;
                // Hmm... need a way to convey result to the outside world later, but keep going with
                // other tasks. In addition, don't want to pretend something is wrong with the
                // queue itself.
                // This will update ready and finished, so we will have made progress.
                build_state.finish_node(&graph, node, result.is_ok());

                // If we executed something, that node must have a key and task.
                let key = graph[node];
                let task = tasks.task(key);
                printer.finished(task.unwrap(), result);
            }
            assert!(pending.is_empty());
            Ok(())
        })
    }
}

impl interface::Scheduler<Key, CommandTaskResult> for ParallelTopoScheduler {
    type Error = BuildError;

    fn schedule(
        &self,
        rebuilder: &impl interface::Rebuilder<Key, CommandTaskResult>,
        tasks: &Tasks,
        start: Vec<Key>,
    ) -> Result<(), Self::Error> {
        self.schedule_internal(rebuilder, tasks, Some(start))
    }

    fn schedule_externals(
        &self,
        rebuilder: &impl interface::Rebuilder<Key, CommandTaskResult>,
        tasks: &Tasks,
    ) -> Result<(), Self::Error> {
        self.schedule_internal(rebuilder, tasks, None)
    }
}

pub fn build_externals<K, V, Scheduler>(
    scheduler: &Scheduler,
    rebuilder: &impl interface::Rebuilder<K, V>,
    tasks: &Tasks,
) -> Result<(), Scheduler::Error>
where
    Scheduler: interface::Scheduler<K, V>,
{
    Ok(scheduler.schedule_externals(rebuilder, tasks)?)
}

pub fn build<K, V, Scheduler>(
    scheduler: &Scheduler,
    rebuilder: &impl interface::Rebuilder<K, V>,
    tasks: &Tasks,
    start: Vec<K>,
) -> Result<(), Scheduler::Error>
where
    Scheduler: interface::Scheduler<K, V>,
{
    Ok(scheduler.schedule(rebuilder, tasks, start)?)
}

pub fn caching_mtime_rebuilder() -> CachingMTimeRebuilder<DiskDirtyCache<SystemDiskInterface>> {
    CachingMTimeRebuilder::new(DiskDirtyCache::new(SystemDiskInterface {}))
}
<gh_stars>10-100
use futures::prelude::*;
use rupnp::{http::Uri, ssdp::URN, Device};
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), rupnp::Error> {
    let url = Uri::from_static("http://192.168.2.49:1400/xml/device_description.xml");
    let service_urn = URN::service("schemas-upnp-org", "ZoneGroupTopology", 1);

    let device = Device::from_url(url).await?;
    let service = device.find_service(&service_urn).unwrap();

    let (sid, mut stream) = service.subscribe(device.url(), 10).await?;

    while let Some(state_vars) = stream.try_next().await? {
        handle(state_vars);
        service.renew_subscription(device.url(), &sid, 10).await?;
    }

    Ok(())
}

fn handle(state_vars: HashMap<String, String>) {
    println!("Change {{");
    for (key, value) in state_vars {
        if value.len() > 256 {
            println!("  {}: ...", key);
        } else {
            println!("  {}: {}", key, value);
        }
    }
    println!("}}");
}
<filename>src/lib.rs
pub mod config;
mod constructs;
mod executor;
pub mod server;
mod sql;
pub mod storage;

pub use config::Config;
use std::io;
use tracing::*;

pub struct Instance {
    config: Config,
}

impl Instance {
    pub fn preload() -> Self {
        Instance {
            config: Config::from_env(),
        }
    }

    pub async fn run(&self) -> Result<(), io::Error> {
        info!("⚙ Launch configuration:\n{}", &self.config


!($path.to_str())));
);

macro_rules! slice(
    ($pointer:expr, $size:expr) => (unsafe {
        ::std::slice::from_raw_parts($pointer, $size)
    });
);

/// An error.
pub type Error = std::io::Error;

/// A result.
pub type Result<T> = std::result::Result<T, Error>;

trait Raw {
    type Target;

    fn raw(&self) -> &Self::Target;
    fn raw_mut(&mut self) -> &mut Self::Target;
}

macro_rules! implement_raw(
    ($kind:ty, $target:ty) => (
        impl ::Raw for $kind {
            type Target = $target;

            #[inline(always)]
            fn raw(&self) -> &Self::Target {
                &self.raw
            }

            #[inline(always)]
            fn raw_mut(&mut self) -> &mut Self::Target {
                &mut self.raw
            }
        }
    );
    ($kind:ident, $target:ty, l) => (
        impl<'l> ::Raw for $kind<'l> {
            type Target = $target;

            #[inline(always)]
            fn raw(&self) -> &Self::Target {
                &self.raw
            }

            #[inline(always)]
            fn raw_mut(&mut self) -> &mut Self::Target {
                &mut self.raw
            }
        }
    );
);

mod analysis;
mod die;
mod dimensions;
mod floorplan;
mod output;
mod power_grid;
mod stack;
mod system;
mod system_matrix;
mod thermal_grid;

pub use analysis::{Analysis, AnalysisType};
pub use die::Die;
pub use dimensions::Dimensions;
pub use floorplan::{Floorplan, FloorplanElement};
pub use stack::{Stack, StackElement};
pub use system::System;
//! Derive macros for ElmJson.

use super::{EnumVariantKind, Intermediate, TypeInfo};
use crate::{EnumRepresentation, EnumVariant, StructField};
use heck::ToLowerCamelCase;
use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Type};

pub fn derive_elm_json(input: TokenStream) -> TokenStream {
    let derive_input = parse_macro_input!(input as DeriveInput);
    let intermediate = match super::derive_input_to_intermediate(derive_input) {
        Ok(intermediate) => intermediate,
        Err(err) => return err.to_compile_error().into(),
    };
    let token_stream = match intermediate_to_token_stream(intermediate) {
        Ok(token_stream) => token_stream,
        Err(err) => return err.to_compile_error().into(),
    };
    TokenStream::from(token_stream)
}

fn intermediate_to_token_stream(
    Intermediate {
        ident,
        elm_type,
        mut generics,
        generics_without_bounds,
        type_info,
    }: Intermediate,
) -> Result<TokenStream2, syn::Error> {
    let decoder_type = format!("{}Decoder", elm_type.to_lower_camel_case());
    let encoder_type = format!("{}Encoder", elm_type.to_lower_camel_case());

    let Coder { encoder, decoder } = match type_info {
        TypeInfo::Unit => struct_unit(&elm_type, &encoder_type, &decoder_type),
        TypeInfo::Newtype(ty) => struct_newtype(&elm_type, &encoder_type, &decoder_type, &ty),
        TypeInfo::Tuple(tys) => struct_tuple(&elm_type, &encoder_type, &decoder_type, &tys),
        TypeInfo::Struct(fields) => struct_named(&elm_type, &encoder_type, &decoder_type, &fields),
        TypeInfo::Enum {
            representation,


========================== */

 /* ==========================================================================
   Helper classes
   ========================================================================== */

/*
 * Hide visually and from screen readers
 */

 .hidden {
  display: none !important;
}

/*
* Hide only visually, but have it available for screen readers:
* https://snook.ca/archives/html_and_css/hiding-content-for-accessibility
*
* 1. For long content, line feeds are not interpreted as spaces and small width
*    causes content to wrap 1 word per line:
*    https://medium.com/@jessebeach/beware-smushed-off-screen-accessible-text-5952a4c2cbfe
*/

.visuallyhidden {
  border: 0;
  clip: rect(0 0 0 0);
  height: 1px;
  margin: -1px;
  overflow: hidden;
  padding: 0;
  position: absolute;
  width: 1px;
  white-space: nowrap; /* 1 */
}

/*
* Extends the .visuallyhidden class to allow the element
* to be focusable when navigated to via the keyboard:
* https://www.drupal.org/node/897638
*/

.visuallyhidden.focusable:active,
.visuallyhidden.focusable:focus {
  clip: auto;
  height: auto;
  margin: 0;
  overflow: visible;
  position: static;
  width: auto;
  white-space: inherit;
}

/*
* Hide visually and from screen readers, but maintain layout
*/

.invisible {
  visibility: hidden;
}

/*
* Clearfix: contain floats
*
* For modern browsers
* 1. The space content is one way to avoid an Opera bug when the
*    `contenteditable` attribute is included anywhere else in the document.
*    Otherwise it causes space to appear at the top and bottom of elements
*    that receive the `clearfix` class.
* 2. The use of `table` rather than `block` is only necessary if using
*    `:before` to contain the top-margins of child elements.
*/

.clearfix:before,
.clearfix:after {
  content: " "; /* 1 */
  display: table; /* 2 */
}

.clearfix:after {
  clear: both;
}

/* ==========================================================================
   EXAMPLE Media Queries for Responsive Design.
   These examples override the primary ('mobile first') styles.
   Modify as content requires.
   ========================================================================== */

   @media only screen and (min-width: 35em) {
    /* Style adjustments for viewports that meet the condition */
}

@media print,
       (-webkit-min-device-pixel-ratio: 1.25),
       (min-resolution: 1.25dppx),
       (min-resolution: 120dpi) {
    /* Style adjustments for high resolution devices */
}

/* ==========================================================================
   Print styles.
   Inlined to avoid the additional HTTP request:
   https://www.phpied.com/delay-loading-your-print-css/
   ========================================================================== */

   @media print {
    *,
    *:before,
    *:after {
        background: transparent !important;
        color: #000 !important; /* Black prints faster */
        -webkit-box-shadow: none !important;
        box-shadow: none !important;
        text-shadow: none !important;
    }

    a,
    a:visited {
        text-decoration: underline;
    }

    a[href]:after {
        content: " (" attr(href) ")";
    }

    abbr[title]:after {
        content: " (" attr(title) ")";
    }

    /*
     * Don't show links that are fragment identifiers,
     * or use the `javascript:` pseudo protocol
     */

    a[href^="#"]:after,
    a[href^="javascript:"]:after {
        content


2r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x59, &mut x60, 0x0, x58, x55);
    let mut x61: u64 = 0;
    let mut x62: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x61, &mut x62, x60, x56, x53);
    let x63: u64 = ((x62 as u64) + x54);
    let mut x64: u64 = 0;
    let mut x65: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x64, &mut x65, 0x0, x45, x57);
    let mut x66: u64 = 0;
    let mut x67: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x66, &mut x67, x65, x47, x59);
    let mut x68: u64 = 0;
    let mut x69: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x68, &mut x69, x67, x49, x61);
    let mut x70: u64 = 0;
    let mut x71: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x70, &mut x71, x69, x51, x63);
    let x72: u64 = ((x71 as u64) + (x52 as u64));
    let mut x73: u64 = 0;
    let mut x74: u64 = 0;
    fiat_p192r1_mulx_u64(&mut x73, &mut x74, x2, (arg2[2]));
    let mut x75: u64 = 0;
    let mut x76: u64 = 0;
    fiat_p192r1_mulx_u64(&mut x75, &mut x76, x2, (arg2[1]));
    let mut x77: u64 = 0;
    let mut x78: u64 = 0;
    fiat_p192r1_mulx_u64(&mut x77, &mut x78, x2, (arg2[0]));
    let mut x79: u64 = 0;
    let mut x80: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x79, &mut x80, 0x0, x78, x75);
    let mut x81: u64 = 0;
    let mut x82: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x81, &mut x82, x80, x76, x73);
    let x83: u64 = ((x82 as u64) + x74);
    let mut x84: u64 = 0;
    let mut x85: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x84, &mut x85, 0x0, x66, x77);
    let mut x86: u64 = 0;
    let mut x87: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x86, &mut x87, x85, x68, x79);
    let mut x88: u64 = 0;
    let mut x89: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u64(&mut x88, &mut x89, x87, x70, x81);
    let mut x90: u64 = 0;
    let mut x91: fiat_p192r1_u1 = 0;
    fiat_p192r1_addcarryx_u


var target = heap32[sp>>2];sp+=4;
	var pname = heap32[sp>>2];sp+=4;
	var value = heap32[sp>>2];sp+=4;

	imandreel_gl.texParameteri(target,pname,value);
}

function myglCullFace (sp)
 {
	var mode = heap32[sp>>2];sp+=4;
	imandreel_gl.cullFace(mode);
 }

 function myglDepthMask (sp)
 {
	var flag = heap32[sp>>2];sp+=4;
	imandreel_gl.depthMask(flag);
 }

 function myglDepthRangef (sp)
 {
	var zNear = heapFloat[sp>>2];sp+=4;
	var zFar = heapFloat[sp>>2];sp+=4;
	imandreel_gl.depthRange(zNear, zFar);
 }

function myglFrontFace (sp)
 {
	var mode = heap32[sp>>2];sp+=4;
	imandreel_gl.frontFace(mode);
 }

 function myglBlendFunc (sp)
 {
	var sfactor = heap32[sp>>2];sp+=4;
	var dfactor = heap32[sp>>2];sp+=4;
	imandreel_gl.blendFunc(sfactor,dfactor);
 }

 function myglBlendColor(sp)
 {
	var red = heapFloat[sp>>2];sp+=4;
	var green = heapFloat[sp>>2];sp+=4;
	var blue = heapFloat[sp>>2];sp+=4;
	var alpha = heapFloat[sp>>2];sp+=4;
	imandreel_gl.blendColor(red,green,blue,alpha);
 }

 function myglBlendEquation(sp)
 {
	var mode = heap32[sp>>2];sp+=4;
	imandreel_gl.blendEquation(mode);
 }

 function myglBlendEquationSeparate(sp)
 {
	var modeRGB = heap32[sp>>2];sp+=4;
	var modeAlpha = heap32[sp>>2];sp+=4;
	imandreel_gl.blendEquationSeparate(modeRGB,modeAlpha);
 }

 function myglBlendFuncSeparate(sp)
 {
	var srcRGB = heap32[sp>>2];sp+=4;
	var dstRGB = heap32[sp>>2];sp+=4;
	var srcAlpha = heap32[sp>>2];sp+=4;
	var dstAlpha = heap32[sp>>2];sp+=4;

	imandreel_gl.blendFuncSeparate(srcRGB,dstRGB,srcAlpha,dstAlpha);
 }

 function myglColorMask (sp)
 {
	var red = heap32[sp>>2];sp+=4;
	var green = heap32[sp>>2];sp+=4;
	var blue = heap32[sp>>2];sp+=4;
	var alpha = heap32[sp>>2];sp+=4;
	imandreel_gl.colorMask(red,green,blue,alpha);
 }

 function removeByElement(arrayName,arrayElement)
 {
    for(var i=0; i<arrayName.length;i++ )
     {
        if(arrayName[i]==arrayElement)
		{
            arrayName.splice(i,1);
			return;
	    }
      }
  }

 function mygetParameter(sp)
 {
	var pname = heap32[sp>>2];sp+=4;
	r_g0 = imandreel_gl.getParameter(pname);
 }

 function mygetProgramParameter(sp)
 {
 	var program_id = heap32[sp>>2];sp+=4;
	var pname = heap32[sp>>2];sp+=4;
	r_g0 = imandreel_gl.getProgramParameter(array_ids_ogl[program_id], pname);
 }

 fun


Returns S_OK if this handler is to be displayed, S_FALSE if it is to be hidden, or an error value otherwise.

## -remarks

To register a dynamic handler, add a REG_SZ named "DynamicHWHandlerCLSID" and assign it the CLSID of your IDynamicHWHandler implementation.

Example:

HKLM
   Software
      Microsoft
         Windows
            CurrentVersion
               Explorer
                  AutoplayHandlers
                     Handlers
                        YourHandler
                           DynamicHWHandlerCLSID = [REG_SZ] {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}

---
UID: NF:shobjidl.INameSpaceTreeControlEvents.OnSelectionChanged
title: INameSpaceTreeControlEvents::OnSelectionChanged (shobjidl.h)
description: Called when the selection changes.
helpviewer_keywords: ["INameSpaceTreeControlEvents interface [Windows Shell]","OnSelectionChanged method","INameSpaceTreeControlEvents.OnSelectionChanged","INameSpaceTreeControlEvents::OnSelectionChanged","OnSelectionChanged","OnSelectionChanged method [Windows Shell]","OnSelectionChanged method [Windows Shell]","INameSpaceTreeControlEvents interface","_shell_INameSpaceTreeControlEvents_OnSelectionChanged","shell.INameSpaceTreeControlEvents_OnSelectionChanged","shobjidl/INameSpaceTreeControlEvents::OnSelectionChanged"]
old-location: shell\INameSpaceTreeControlEvents_OnSelectionChanged.htm
tech.root: shell
ms.assetid: ecc84586-ec37-4ece-a890-6adfc7a94ad6
ms.date: 12/05/2018
ms.keywords: INameSpaceTreeControlEvents interface [Windows Shell],OnSelectionChanged method, INameSpaceTreeControlEvents.OnSelectionChanged, INameSpaceTreeControlEvents::OnSelectionChanged, OnSelectionChanged, OnSelectionChanged method [Windows Shell], OnSelectionChanged method [Windows Shell],INameSpaceTreeControlEvents interface, _shell_INameSpaceTreeControlEvents_OnSelectionChanged, shell.INameSpaceTreeControlEvents_OnSelectionChanged, shobjidl/INameSpaceTreeControlEvents::OnSelectionChanged
req.header: shobjidl.h
req.include-header:
req.target-type: Windows
req.target-min-winverclnt: Windows Vista [desktop apps only]
req.target-min-winversvr: Windows Server 2008 [desktop apps only]
req.kmdf-ver:
req.umdf-ver:
req.ddi-compliance:
req.unicode-ansi:
req.idl: Shobjidl.idl
req.max-support:
req.namespace:
req.assembly:
req.type-library:
req.lib:
req.dll:
req.irql:
targetos: Windows
req.typenames:
req.redist:
ms.custom: 19H1
f1_keywords:
 - INameSpaceTreeControlEvents::OnSelectionChanged
 - shobjidl/INameSpaceTreeControlEvents::OnSelectionChanged
dev_langs:
 - c++
topic_type:
 - APIRef
 - kbSyntax
api_type:
 - COM
api_location:
 - Shobjidl.h
api_name:
 - INameSpaceTreeControlEvents.OnSelectionChanged
---

# INameSpaceTreeControlEvents::OnSelectionChanged

## -description

Called when the selection changes.

## -parameters

### -param psiaSelection [in]

Type: IShellItemArray*

An array of IS


cipatedFlags, err := AttestationParticipationFlagIndices(state, att.Data, att.InclusionDelay)
		if err != nil {
			return nil, err
		}
		committee, err := helpers.BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
		if err != nil {
			return nil, err
		}
		indices, err := attestation.AttestingIndices(att, committee)
		if err != nil {
			return nil, err
		}
		cfg := params.BeaconConfig()
		sourceFlagIndex := cfg.TimelySourceFlagIndex
		targetFlagIndex := cfg.TimelyTargetFlagIndex
		headFlagIndex := cfg.TimelyHeadFlagIndex
		for _, index := range indices {
			has, err := HasValidatorFlag(epochParticipation[index], sourceFlagIndex)
			if err != nil {
				return nil, err
			}
			if participatedFlags[sourceFlagIndex] && !has {
				epochParticipation[index], err = AddValidatorFlag(epochParticipation[index], sourceFlagIndex)
				if err != nil {
					return nil, err
				}
			}
			has, err = HasValidatorFlag(epochParticipation[index], targetFlagIndex)
			if err != nil {
				return nil, err
			}
			if participatedFlags[targetFlagIndex] && !has {
				epochParticipation[index], err = AddValidatorFlag(epochParticipation[index], targetFlagIndex)
				if err != nil {
					return nil, err
				}
			}
			has, err = HasValidatorFlag(epochParticipation[index], headFlagIndex)
			if err != nil {
				return nil, err
			}
			if participatedFlags[headFlagIndex] && !has {
				epochParticipation[index], err = AddValidatorFlag(epochParticipation[index], headFlagIndex)
				if err != nil {
					return nil, err
				}
			}
		}
	}

	if err := state.SetPreviousParticipationBits(epochParticipation); err != nil {
		return nil, err
	}

	return state, nil
}
// Package validators contains libraries to shuffle validators
// and retrieve active validator indices from a given slot
// or an attestation. It also provides helper functions to locate
// validator based on pubic key.
package validators

import (
	"context"

	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
	"github.com/OffchainLabs/prysm/v6/config/params"
	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
	"github.com/OffchainLabs/prysm/v6/math"
	mathutil "github.com/OffchainLabs/prysm/v6/math"
	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
	"github.com/OffchainLabs/prysm/v6/runtime/version"
	"github.com/OffchainLabs/prysm/v6/time/slots"
	"github.com/pkg/errors"
)

// ExitInfo provides information about validator exits in the state.
type ExitInfo struct {
	HighestExitEpoch   primitives.Epoch
	Churn              uint64
	TotalActiveBalance uint64
}

// ErrValidatorAlreadyExited is an error raised when trying to process an exit of
// an already exited validator
var ErrValidatorAlreadyExited = errors.New("validator already exited")

// ExitInformation returns information about validator exits.
func ExitInformation(s state.BeaconState) *ExitInfo {
	exitInfo := &ExitInfo{}

	farFutureEpoch := params.BeaconConfig().FarFutureEpoch
	currentEpoch := slots.ToEpoch(s.Slot())
	totalActiveBalance := uint64(0)

	err := s.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {


pectRoot != "." {
					expectedPath = filepath.Join(dir, tt.expectRoot)
				}
				if root != expectedPath {
					t.Errorf("Expected root %s but got %s", expectedPath, root)
				}
			}
		})
	}
}

func TestValidatePluginName(t *testing.T) {
	tests := []struct {
		name         string
		setup        func(dir string) error
		pluginRoot   string
		expectedName string
		expectError  bool
	}{
		{
			name: "matching directory and plugin name",
			setup: func(dir string) error {
				subdir := filepath.Join(dir, "my-plugin")
				if err := os.MkdirAll(subdir, 0755); err != nil {
					return err
				}
				yaml := `name: my-plugin
version: 1.0.0
usage: test
description: test`
				return os.WriteFile(filepath.Join(subdir, "plugin.yaml"), []byte(yaml), 0644)
			},
			pluginRoot:   "my-plugin",
			expectedName: "my-plugin",
			expectError:  false,
		},
		{
			name: "different directory and plugin name",
			setup: func(dir string) error {
				subdir := filepath.Join(dir, "wrong-name")
				if err := os.MkdirAll(subdir, 0755); err != nil {
					return err
				}
				yaml := `name: my-plugin
version: 1.0.0
usage: test
description: test`
				return os.WriteFile(filepath.Join(subdir, "plugin.yaml"), []byte(yaml), 0644)
			},
			pluginRoot:   "wrong-name",
			expectedName: "wrong-name",
			expectError:  false, // Currently we don't error on mismatch
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dir := t.TempDir()
			if err := tt.setup(dir); err != nil {
				t.Fatalf("Setup failed: %v", err)
			}

			pluginRoot := filepath.Join(dir, tt.pluginRoot)
			err := validatePluginName(pluginRoot, tt.expectedName)
			if tt.expectError {
				if err == nil {
					t.Error("Expected error but got none")
				}
			} else {
				if err != nil {
					t.Errorf("Unexpected error: %v", err)
				}
			}
		})
	}
}
/*
Copyright The Helm Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package installer // import "helm.sh/helm/v4/internal/plugin/installer"

import (
	"archive/tar"
	"bytes"
	"compress/gzip"
	"encoding/base64"
	"errors"
	"fmt"
	"io/fs"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"strings"
	"syscall"
	"testing"

	"helm.sh/helm/v4/internal/test/ensure"
	"helm.sh/helm/v4/pkg/getter"
	"helm.sh/helm/v4/pkg/helmpath"
)

var _ Installer = new(HTTPInstaller)

// Fake http client
type TestHTTPGetter struct {
	MockResponse *bytes.Buffer
	MockError    error
}

func (t *TestHTTPGetter) Get(_ string, _ ...getter.Option) (*bytes.Buffer, error) {
	return t.MockResponse, t.


//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514832-hiddenorhashiddenancestor?language=objc
func (m_ MenuItem) IsHiddenOrHasHiddenAncestor() bool {
	rv := objc.Call[bool](m_, objc.Sel("isHiddenOrHasHiddenAncestor"))
	return rv
}

// The user-assigned key equivalent for the menu item. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514850-userkeyequivalent?language=objc
func (m_ MenuItem) UserKeyEquivalent() string {
	rv := objc.Call[string](m_, objc.Sel("userKeyEquivalent"))
	return rv
}

// The menu item’s image. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514819-image?language=objc
func (m_ MenuItem) Image() Image {
	rv := objc.Call[Image](m_, objc.Sel("image"))
	return rv
}

// The menu item’s image. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514819-image?language=objc
func (m_ MenuItem) SetImage(value IImage) {
	objc.Call[objc.Void](m_, objc.Sel("setImage:"), value)
}

// The menu item's action-method selector. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514825-action?language=objc
func (m_ MenuItem) Action() objc.Selector {
	rv := objc.Call[objc.Selector](m_, objc.Sel("action"))
	return rv
}

// The menu item's action-method selector. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514825-action?language=objc
func (m_ MenuItem) SetAction(value objc.Selector) {
	objc.Call[objc.Void](m_, objc.Sel("setAction:"), value)
}

// The menu item indentation level for the menu item. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514809-indentationlevel?language=objc
func (m_ MenuItem) IndentationLevel() int {
	rv := objc.Call[int](m_, objc.Sel("indentationLevel"))
	return rv
}

// The menu item indentation level for the menu item. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514809-indentationlevel?language=objc
func (m_ MenuItem) SetIndentationLevel(value int) {
	objc.Call[objc.Void](m_, objc.Sel("setIndentationLevel:"), value)
}

// The menu item's target. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514843-target?language=objc
func (m_ MenuItem) Target() objc.Object {
	rv := objc.Call[objc.Object](m_, objc.Sel("target"))
	return rv
}

// The menu item's target. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/documentation/appkit/nsmenuitem/1514843-target?language=objc
func (m_ MenuItem) SetTarget(value objc.IObject) {
	objc.Call[objc.Void](m_, objc.Sel("setTarget:"), value)
}

// The content view for the menu item. [Full Topic]
//
// [Full Topic]: https://developer.apple.com/docume


lic Integer getHegeTypes() {
        return hegeTypes;
    }

    /**
	 * 设置：是否合格
	 */
    public void setHegeTypes(Integer hegeTypes) {
        this.hegeTypes = hegeTypes;
    }
    /**
	 * 获取：备注
	 */
    public String getJianzaocaiwuContent() {
        return jianzaocaiwuContent;
    }

    /**
	 * 设置：备注
	 */
    public void setJianzaocaiwuContent(String jianzaocaiwuContent) {
        this.jianzaocaiwuContent = jianzaocaiwuContent;
    }
    /**
	 * 获取：验收时间
	 */
    public Date getInsertTime() {
        return insertTime;
    }

    /**
	 * 设置：验收时间
	 */
    public void setInsertTime(Date insertTime) {
        this.insertTime = insertTime;
    }
    /**
	 * 获取：创建时间  show1 show2 photoShow
	 */
    public Date getCreateTime() {
        return createTime;
    }

    /**
	 * 设置：创建时间  show1 show2 photoShow
	 */
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    }
package com.entity.model;

import com.entity.YanshouGongyiEntity;

import com.baomidou.mybatisplus.annotations.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;

/**
 * 工艺验收
 * 接收传参的实体类
 *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
 * 取自ModelAndView 的model名称
 */
public class YanshouGongyiModel implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    private Integer id;

    /**
     * 项目
     */
    private Integer xiangmuId;

    /**
     * 员工
     */
    private Integer yuangongId;

    /**
     * 工艺名称
     */
    private String yanshouGongyiName;

    /**
     * 验收部位
     */
    private String yanshouGongyiBuwei;

    /**
     * 使用标准
     */
    private String yanshouGongyiBiaozhun;

    /**
     * 实际使用
     */
    private String yanshouGongyiShijishiyong;

    /**
     * 附件
     */
    private String jianzaojinduFile;

    /**
     * 是否合格
     */
    private Integer hegeTypes;

    /**
     * 验收时间
     */
    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
	@DateTimeFormat
    private Date yanshouTime;

    /**
     * 备注
     */
    private String yanshouGongyiContent;

    /**
     * 录入时间
     */
    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
	@DateTimeFormat
    private Date insertTime;

    /**
     * 创建时间
     */
    @JsonFormat(locale="zh", time


  delete rule['模板']
            }
        }
        if (rule.模板 && muban.hasOwnProperty(rule.模板)) {
            print('继承模板:' + rule.模板);
            rule = Object.assign(muban[rule.模板], rule);
        }
        /** 处理一下 rule规则关键字段没传递的情况 **/
        let rule_cate_excludes = (rule.cate_exclude || '').split('|').filter(it => it.trim());
        let rule_tab_excludes = (rule.tab_exclude || '').split('|').filter(it => it.trim());
        rule_cate_excludes = rule_cate_excludes.concat(CATE_EXCLUDE.split('|').filter(it => it.trim()));
        rule_tab_excludes = rule_tab_excludes.concat(TAB_EXCLUDE.split('|').filter(it => it.trim()));

        rule.cate_exclude = rule_cate_excludes.join('|');
        rule.tab_exclude = rule_tab_excludes.join('|');

        rule.类型 = rule.类型 || '影视'; // 影视|听书|漫画|小说
        rule.url = rule.url || '';
        rule.double = rule.double || false;
        rule.homeUrl = rule.homeUrl || '';
        rule.detailUrl = rule.detailUrl || '';
        rule.searchUrl = rule.searchUrl || '';
        rule.homeUrl = rule.host && rule.homeUrl ? urljoin(rule.host, rule.homeUrl) : (rule.homeUrl || rule.host);
        rule.homeUrl = cheerio.jinja2(rule.homeUrl, {rule: rule});
        rule.detailUrl = rule.host && rule.detailUrl ? urljoin(rule.host, rule.detailUrl) : rule.detailUrl;
        rule.二级访问前 = rule.二级访问前 || '';
        if (rule.url.includes('[') && rule.url.includes(']')) {
            let u1 = rule.url.split('[')[0]
            let u2 = rule.url.split('[')[1].split(']')[0]
            rule.url = rule.host && rule.url ? urljoin(rule.host, u1) + '[' + urljoin(rule.host, u2) + ']' : rule.url;
        } else {
            rule.url = rule.host && rule.url ? urljoin(rule.host, rule.url) : rule.url;
        }
        if (rule.searchUrl.includes('[') && rule.searchUrl.includes(']') && !rule.searchUrl.includes('#')) {
            let u1 = rule.searchUrl.split('[')[0]
            let u2 = rule.searchUrl.split('[')[1].split(']')[0]
            rule.searchUrl = rule.host && rule.searchUrl ? urljoin(rule.host, u1) + '[' + urljoin(rule.host, u2) + ']' : rule.searchUrl;
        } else {
            rule.searchUrl = rule.host && rule.searchUrl ? urljoin(rule.host, rule.searchUrl) : rule.searchUrl;
        }

        rule.timeout = rule.timeout || 5000;
        rule.encoding = rule.编码 || rule.encoding || 'utf-8';
        rule.search_encoding = rule.搜索编码 || rule.search_encoding || '';
        rule.图片来源 = rule.图片来源 || '';
        rule.图片替换 = rule.图片替换 || '';
        rule.play_json = rule.hasOwnProperty('play_json') ? rule.play_json : [];
        rule.pagecount = rule.hasOwnProperty('pagecount') ? rule.pagecount : {};
        rule.proxy_rule = rule.hasOwnProperty('proxy_rule') ? rule.proxy_rule : '';
        if (!rule.hasOwnProperty('sniffer')) { // 默认关闭辅助嗅探
            rule.sniffer = false;
        }
        rule.sniffer = rule.hasOwnProperty('sniffer') ? rule.sniffer : '';
        rule


ISITED;

    queue<Mesh::Face *> q;
    q.push(xmax_face);
    while (!q.empty())
    {
      Mesh::Face * face = q.front();
      q.pop();

      if (!face)
      {
        THEA_WARNING << mesh.getName() << ": Null face";
        continue;
      }

      alwaysAssertM(face->attr().flag == VISITED, string(mesh.getName()) + ": Unvisited face in queue");

      for (Mesh::Face::EdgeConstIterator fei = face->edgesBegin(); fei != face->edgesEnd(); ++fei)
      {
        Mesh::Edge * edge = *fei;
        for (Mesh::Edge::FaceConstIterator efi = edge->facesBegin(); efi != edge->facesEnd(); ++efi)
        {
           Mesh::Face * adj_face = *efi;
           if (adj_face->attr().flag == VISITED)
             continue;

           if (!consistentWinding(face, adj_face, edge))
           {
             adj_face->reverseWinding();
             num_flipped++;
           }

           adj_face->attr().flag = VISITED;
           q.push(adj_face);
        }
      }
    }
  }

  for (Mesh::FaceIterator fi = mesh.facesBegin(); fi != mesh.facesEnd(); ++fi)
    fi->updateNormal();

  for (Mesh::VertexIterator vi = mesh.verticesBegin(); vi != mesh.verticesEnd(); ++vi)
    if (!vi->hasPrecomputedNormal())
      vi->updateNormal();

  // checkProblems(mesh);

  if (verbose)
  {
    THEA_CONSOLE << "orient('" << mesh.getName() << "'): Flipped " << num_flipped << '/' << mesh.numFaces() << " faces in "
                 << num_cc << " connected components";
  }

  return false;
}

struct SDFOrienter
{
  SDFOrienter(Local::ShapeDiameter<Mesh> * sdf_) : sdf(sdf_) {}

  bool operator()(Mesh & mesh)
  {
    long num_flipped = 0;
    for (Mesh::FaceIterator fi = mesh.facesBegin(); fi != mesh.facesEnd(); ++fi)
    {
      if (fi->numVertices() < 3)
        continue;

      Vector3 centroid = Vector3::zero();
      for (Mesh::Face::VertexConstIterator fvi = fi->verticesBegin(); fvi != fi->verticesEnd(); ++fvi)
        centroid += (*fvi)->getPosition();

      centroid /= fi->numVertices();

      Vector3 n = fi->getNormal();
      double sdf_pos = sdf->compute(centroid,  n, false);
      double sdf_neg = sdf->compute(centroid, -n, false);
#if 0
      if ((sdf_neg < 0 || sdf_neg > 0.4) && (sdf_pos < 0 || sdf_pos > 0.4))
      {
        if (fi->getNormal().z() < 0)
        {
          fi->reverseWinding();
          num_flipped++;
        }
      }
      else
#endif
      if (sdf_neg >= 0 && (sdf_pos < 0 || sdf_neg < sdf_pos))
      {
        fi->reverseWinding();
        num_flipped++;
      }
    }

    if (verbose)
    {
      THEA_CONSOLE << "orient-sdf('" << mesh.getName() << "'): Flipped " << num_flipped << '/' << mesh.numFaces() << " faces";
    }

    return false;
  }

  Local::ShapeDiameter<Mesh> * sdf;

}; // struct SDFOrienter

void
orientSDF(MG & mesh_group)
{
  Local::ShapeDiameter<Mesh> sdf(mesh_group);
  SDFOrienter func(&sdf);
  mesh_group.forEachMesh


import org.semanticweb.owlapi.model.RemoveAxiom;

/**
 *

 * Title: IncrementalClassifierExample
 *

 *

 * Description: This programs shows the usage and performance of the incremental classifier
 *

 *

 * Copyright: Copyright (c) 2008
 *

 *

 * Company: Clark & Parsia, LLC. <http://www.clarkparsia.com>
 *

 *
 * @author Markus Stocker
 */
public class IncrementalClassifierExample
{

	// The ontology we use for classification
	private static final String	file	= "file:src/main/resources/data/simple-galen.owl";
	// Don't modify this
	private static final String	NS		= "http://www.co-ode.org/ontologies/galen#";

	public void run() throws OWLOntologyCreationException
	{
		// Load the ontology file into an OWL ontology object
		final OWLOntology ontology = OWL._manager.loadOntology(IRI.create(file));

		// Get some entities
		final OWLClass headache = OWL.Class(NS + "Headache");
		final OWLClass pain = OWL.Class(NS + "Pain");

		// Get an instance of the incremental classifier
		final IncrementalClassifier classifier = new IncrementalClassifier(ontology);

		// We need some timing to show the performance of the classification
		final Timers timers = new Timers();

		// We classify the ontology and use a specific timer to keep track of
		// the time required for the classification
		Timer t = timers.createTimer("First classification");
		t.start();
		classifier.classify();
		t.stop();

		System.out.println("\nClassification time: " + t.getTotal() + "ms");
		System.out.println("Subclasses of " + pain + ": " + classifier.getSubClasses(pain, true).entities().map(OWLClass::toString).collect(Collectors.joining(",")) + "\n");

		// Now create a new OWL axiom, subClassOf(Headache, Pain)
		final OWLAxiom axiom = OWL.subClassOf(headache, pain);

		// Add the axiom to the ontology, which creates a change event
		OWL._manager.applyChange(new AddAxiom(ontology, axiom));

		// Now we create a second timer to keep track of the performance of the
		// second classification
		t = timers.createTimer("Second classification");
		t.start();
		classifier.classify();
		t.stop();

		System.out.println("\nClassification time: " + t.getTotal() + "ms");
		System.out.println("Subclasses of " + pain + ": " + classifier.getSubClasses(pain, true).entities().map(OWLClass::toString).collect(Collectors.joining(",")) + "\n");

		// Remove the axiom from the ontology, which creates a change event
		OWL._manager.applyChange(new RemoveAxiom(ontology, axiom));

		// Now we create a third timer to keep track of the performance of the
		// third classification
		timers.startTimer("Third classification");
		classifier.classify();
		timers.stopTimer("Third classification");

		System.out.println("\nClassification time: " + t.getTotal() + "ms");
		System.out.println("Subclasses of " + pain + ": " + classifier.getSubClasses(pain, true).entities().map(OWLClass::toString).collect(Collectors.joining(",")) + "\n");

		// Finally, print the timing. As you can see, the second classification
		// takes significantly less time, which is the characteristic of the
		// incremental classifier.
		System.out.println("Timers summary");
		for (final Timer timer : timers.getTimers())
			if (!timer.isStarted()) System.out.println(timer.getName() + ": " + timer.getTotal() + "ms");
	}

	public static void main(final String[] args) thr


리는 VisionGPT-3D에서 사용자를 위한 응답으로서 라벨링된 2D 이미지를 3D 표현으로 변환할 것을 제안했다. 사용자가 다른 답변 또는 스타일 응답을 원할 때 관련 3D 이미지를 생성하도록 모델을 훈련시키기 위해 3D 이미지의 객체를 훈련 데이터세트로 추가로 레이블링했다. 전체 네트워크 아키텍처는 아래의 그림 4에 설명되어 있다.\n' +
      '\n' +
      '도 4: AI 기반 2D-3D 영상 변환기 파이프라인\n' +
      '\n' +
      '본 논문에서는 3차원 영상 내에서 객체 분할의 혁신에 초점을 맞춘다. 깊이 맵에서 객체 분할을 위해 많은 기존 알고리즘과 방법이 사용될 수 있다. 깊이 맵을 정확하게 분석하는 것은 성공적인 포인트 클라우드를 생성하는 데 도움이 될 수 있다. 효율적인 객체 분할은 깊이 맵으로 장면에 대한 더 나은 이해로 이어진다. 컴퓨터 비전 처리에서는 임계화, 유역 분할, 그래프 컷 분할, 평균 이동 분할, 슈퍼픽셀 기반 분할, 영역 확장과 같은 객체 분할 알고리즘이 일반적이다. 분할 알고리즘들의 선택은 깊이 맵의 특정 특성들, 장면의 복잡성 및 원하는 레벨의 분할 세부사항들에 의존한다. 임계값은 영역이 특정 임계값에 의해 분리되는 기본 기술이다. 영역 성장은 시드 픽셀에서 시작하여 깊이 값이 유사하면 이웃 픽셀을 영역에 추가한다. 시드 선택은 알고리즘의 성능과 결과에 영향을 미�