    .build()
            );
        } else if (EventStatus.CREATOR == eventParticipation.getEventStatus()) {
            // 생성자인 경우 생성자 & 참여자로 변경
            eventParticipation.updateEventStatus(EventStatus.CREATOR_AND_PARTICIPANT);
        }

        List<DaySchedule> daySchedules = createDayScheduleRequest.daySchedules();
        List<Selection> selections = new ArrayList<>();
        for (DaySchedule daySchedule : daySchedules) {
            String day = daySchedule.day();
            List<String> times = daySchedule.times();
            List<Schedule> schedules = scheduleRepository.findAllByEventAndDay(event, day)
                    .orElseThrow(() -> new CustomException(ScheduleErrorStatus._NOT_FOUND_DAY_SCHEDULES));

            for (Schedule schedule : schedules) {
                if (times.contains(schedule.getTime())) {
                    selections.add(Selection.builder()
                            .user(user)
                            .schedule(schedule)
                            .build());
                }
            }
        }
        selectionRepository.deleteAllByUserAndEvent(user, event);
        selectionBatchRepository.insertAll(selections);
    }

    /**
     * 날짜 스케줄 등록 메서드 (비로그인).
     *
     * 비로그인 사용자가 날짜 스케줄을 등록합니다.
     * 기존 Selection 데이터를 삭제하고 새 Selection 데이터를 저장합니다.
     *
     * @param createDateScheduleRequest 날짜 스케줄 등록 요청 데이터
     */
    @Transactional
    public void createDateSchedulesForAnonymousUser(CreateDateScheduleRequest createDateScheduleRequest) {
        Event event = eventRepository.findByEventId(UUID.fromString(createDateScheduleRequest.eventId()))
                .orElseThrow(() -> new CustomException(EventErrorStatus._NOT_FOUND_EVENT));
        Member member = memberRepository.findByMemberId(UUID.fromString(createDateScheduleRequest.memberId()))
                .orElseThrow(() -> new CustomException(MemberErrorStatus._NOT_FOUND_MEMBER));

        List<DateSchedule> dateSchedules = createDateScheduleRequest.dateSchedules();
        List<Selection> selections = new ArrayList<>();
        for (DateSchedule dateSchedule : dateSchedules) {
            String date = dateSchedule.date();
            List<String> times = dateSchedule.times();
            List<Schedule> schedules = scheduleRepository.findAllByEventAndDate(event, date)
                    .orElseThrow(() -> new CustomException(ScheduleErrorStatus._NOT_FOUND_DATE_SCHEDULES));

            for (Schedule schedule : schedules) {
                if (times.contains(schedule.getTime())) {
                    selections.add(Selection.builder()
                            .member(member)
                            .schedule(schedule)
                            .build());
                }
            }
        }
        selectionRepository.deleteAllByMember(member);
        selectionBatchRepository.insertAll(selections);
    }

    /**
     * 날짜 스케줄 등록 메서드 (로그인).
     *
     * 로그인 사용자가 날짜 스케줄을 등록합니다.
     * 기존 Selection 데이터를 삭제하고 새 Selection 데이터를 저장합니다.
     *
     * @param createDateScheduleRequest 날짜 스케줄 등록 요청 데이터
     * @param authorizationHeader 사용자


|35|30.00|86.40|42.08|6.01",
				"nil|376|35|23.40|87.30|18.04|6.01",
				"nil|376|35|29.40|87.30|42.08|6.01",
				"nil|376|35|24.00|88.20|6.01|6.01",
				"nil|376|35|29.40|88.20|42.08|6.01",
				"nil|376|35|28.80|89.10|42.08|12.02",
				"nil|376|35|28.20|90.90|42.08|6.01",
				"nil|376|35|28.80|91.80|36.07|6.01",
				"nil|376|35|29.40|92.70|24.05|6.01",
				"nil|376|35|30.60|93.60|6.01|6.01"
			}
		}
	},
	[30414] = {
		["Quest"] = "A Dish for Haohan|0|90|90|0|0|0",
		["Start"] = "57402|376|32|44.7|34.1",
		["End"] = "57402|376|32|44.7|34.1",
		["Objectives"] = 	{
			[1] = 		{
				"nil|554|35|68.40|30.60|18.04|6.01",
				"nil|554|35|67.20|31.50|36.07|6.01",
				"nil|554|35|66.60|32.40|42.08|6.01",
				"nil|554|35|66.60|33.30|48.10|6.01",
				"nil|554|35|66.00|34.20|54.11|6.01",
				"nil|554|35|66.00|35.10|60.12|12.02",
				"nil|554|35|66.60|36.90|48.10|6.01",
				"nil|554|35|67.80|37.80|24.05|6.01",
				"nil|554|35|67.80|58.50|6.01|6.01",
				"nil|554|35|67.20|59.40|18.04|6.01",
				"nil|554|35|67.80|60.30|6.01|6.01",
				"nil|554|35|55.20|69.30|12.02|6.01",
				"nil|554|35|54.00|70.20|30.06|6.01",
				"nil|554|35|52.80|71.10|48.10|6.01",
				"nil|554|35|52.20|72.00|60.12|6.01",
				"nil|554|35|51.60|72.90|72.14|6.01",
				"nil|554|35|51.00|73.80|78.16|6.01",
				"nil|554|35|50.40|74.70|90.18|6.01",
				"nil|554|35|49.80|75.60|96.19|6.01",
				"nil|554|35|49.20|76.50|108.22|6.01",
				"nil|554|35|49.20|77.40|108.22|6.01",
				"nil|554|35|48.60|78.30|120.24|12.02",
				"nil|554|35|48.00|80.10|132.26|12.02",
				"nil|554|35|48.00|81.90|126.25|12.02",
				"nil|554|35|48.60|83.70|114.23|6.01",
				"nil|554|35|48.60|84.60|114.23|6.01",


}

// CullingShader when implemented can be used in the RenderSystem to test if an entity should be rendered.
type CullingShader interface {
	Shader
	// PrepareCulling is called once per frame for the shader to initialize culling calculation.
	PrepareCulling()
	ShouldDraw(*RenderComponent, *SpaceComponent) bool
}

func setBufferValue(buffer []float32, index int, value float32, changed *bool) {
	if buffer[index] != value {
		buffer[index] = value
		*changed = true
	}
}

// colorToFloat32 returns the float32 representation of the given color
func colorToFloat32(c color.Color) float32 {
	colorR, colorG, colorB, colorA := c.RGBA()
	colorR >>= 8
	colorG >>= 8
	colorB >>= 8
	colorA >>= 8

	red := colorR
	green := colorG << 8
	blue := colorB << 16
	alpha := colorA << 24

	return math.Float32frombits((alpha | blue | green | red) & 0xfeffffff)
}

// AddShader adds a shader to the list of shaders for initalization. They should
// be added before the Rendersystem is added, such as in the scene's Preload.
func AddShader(s Shader) {
	shaders = append(shaders, s)
}

var shaderInitMutex sync.Mutex

func initShaders(w *ecs.World) error {
	shaderInitMutex.Lock()
	defer shaderInitMutex.Unlock()

	if !shadersSet {
		var err error

		for _, shader := range shaders {
			err = shader.Setup(w)
			if err != nil {
				return err
			}
		}

		shadersSet = true
	}
	return nil
}

// LoadShader takes a Vertex-shader and Fragment-shader, compiles them and attaches them to a newly created glProgram.
// It will log possible compilation errors
func LoadShader(vertSrc, fragSrc string) (*gl.Program, error) {
	vertShader := engo.Gl.CreateShader(engo.Gl.VERTEX_SHADER)
	engo.Gl.ShaderSource(vertShader, vertSrc)
	engo.Gl.CompileShader(vertShader)
	if !engo.Gl.GetShaderiv(vertShader, engo.Gl.COMPILE_STATUS) {
		errorLog := engo.Gl.GetShaderInfoLog(vertShader)
		return nil, VertexShaderCompilationError{errorLog}
	}
	defer engo.Gl.DeleteShader(vertShader)

	fragShader := engo.Gl.CreateShader(engo.Gl.FRAGMENT_SHADER)
	engo.Gl.ShaderSource(fragShader, fragSrc)
	engo.Gl.CompileShader(fragShader)
	if !engo.Gl.GetShaderiv(fragShader, engo.Gl.COMPILE_STATUS) {
		errorLog := engo.Gl.GetShaderInfoLog(fragShader)
		return nil, FragmentShaderCompilationError{errorLog}
	}
	defer engo.Gl.DeleteShader(fragShader)

	program := engo.Gl.CreateProgram()
	engo.Gl.AttachShader(program, vertShader)
	engo.Gl.AttachShader(program, fragShader)
	engo.Gl.LinkProgram(program)

	return program, nil
}

func newCamera(w *ecs.World) {
	shaderInitMutex.Lock()
	defer shaderInitMutex.Unlock()
	var cam *CameraSystem
	for _, system := range w.Systems() {
		switch sys := system.(type) {
		case *CameraSystem:
			cam = sys
		}
	}
	if cam == nil {
		log.Println("Camera system was not found when changing scene!")
		return
	}
	for _, shader := range shaders {
		shader.SetCamera(cam)
	}
}

// VertexShaderCompilationError is returned whenever the `LoadShader` method was unable to compile your Vertex-shader (GLSL)
type VertexShaderCompilationError struct {
	OpenGLError string
}

//


 Crystal",nil,nil,{[490]={{81.61,60.57},{38.22,81.82},{42.52,34.02},{27.74,46.44},{49.96,15.57},{39.72,26.92},{69.58,34.97},{68.34,25.38},{51.54,13.54}}},490},
[164781] = {"Yellow Power Crystal",nil,nil,{[490]={{26.85,50.54},{33.86,76.88},{23.14,40.19},{25.73,63.3},{28.95,76.89},{40.49,75.26},{35.77,54.57},{30.1,21.19},{57.37,82.63},{56.32,73.63},{53.73,38.78},{73.03,65.46},{76.62,43.84},{66.18,21.11},{69.04,28.81},{75.1,37.59},{26.07,59.52},{23.01,59.18},{71.97,23.07},{72.92,46.79},{75.29,61.52},{70.0,77.19},{59.76,49.35}}},490},
[164798] = {"Evoroot",nil,nil,{[357]={{44.54,10.13},{44.52,10.22},{44.6,10.18}}},357},
[164799] = {"Videre Elixir Spell Focus (DND)",nil,nil,{[440]={{54.02,28.8}}},440},
[164826] = {"Aura 1 - Linken",nil,nil,{[440]={{53.82,29.06}}},440},
[164827] = {"Aura 2 - Linken",nil,nil,{[440]={{53.82,29.06}}},440},
[164838] = {"JD Red Crystal 1",nil,nil,{[490]={{42.01,2.39}}},490},
[164840] = {"Mailbox",nil,nil,{[45]={{73.86,33.11}}},45,29},
[164867] = {"WANTED",{4081},nil,{[3]={{3.74,47.43}}},3},
[164868] = {"KILL ON SIGHT",{4082},nil,{[3]={{3.94,46.73}}},3},
[164869] = {"Spectral Chalice",{4083},{4083},{[1585]={{-1,-1}}},1585},
[164870] = {"Smoke Emitter 02",nil,nil,{[17]={{44.59,28.88},{44.53,28.77},{44.42,27.64},{44.32,27.57},{44.44,27.43}}},17},
[164881] = {"Cleansed Night Dragon",nil,nil,{[361]={{52.45,86.14}}},361},
[164882] = {"Cleansed Songflower",nil,nil,{[361]={{52.94,88.95}}},361},
[164883] = {"Cleansed Whipper Root",nil,nil,{[361]={{45.19,21.6}}},361},
[164884] = {"Cleansed Windblossom",nil,nil,{[361]={{50.0,80.0}}},361},
[164885] = {"Corrupted Night Dragon",{4119},{4119},{[361]={{52.45,86.14}}},361},
[164886] = {"Corrupted Songflower",{2523},{2523},{[361]={{52.94,88.95}}},361},
[164887] = {"Corrupted Windblossom",{4343},{4343},{[361]={{50.0,80.0}}},361},
[164888] = {"Corrupted Whipper Root",{4117},{4117},{[361]={{45.19,21.6}}},361},
[164890] = {"Smoked Meat Rack",nil,nil,{[11]={{38.26,45.98}}},11},
[164891] = {"Smoked Meat Rack",nil,nil


s := []struct {
		name       string
		tableRows  []userTableRow
		email      string
		expIsExist bool
	}{
		{
			name:       "email doesn't exist",
			email:      "user@example.com",
			tableRows:  []userTableRow{},
			expIsExist: false,
		},
		{
			name:       "email found",
			email:      "user@example.com",
			tableRows:  []userTableRow{{email: "user@example.com"}},
			expIsExist: true,
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			dbtest.AccessTestDB(
				dbConnector,
				dbMigrationTool,
				dbMigrationRoot,
				dbConfig,
				func(sqlDB *sql.DB) {
					insertUserTableRows(t, sqlDB, testCase.tableRows)

					userRepo := sqldb.NewUserSQL(sqlDB)
					gotIsExist, err := userRepo.IsEmailExist(testCase.email)
					assert.Equal(t, nil, err)
					assert.Equal(t, testCase.expIsExist, gotIsExist)
				})
		})
	}
}

func TestUserSql_GetUserByID(t *testing.T) {
	testCases := []struct {
		name      string
		tableRows []userTableRow
		id        string
		hasErr    bool
		expUser   entity.User
	}{
		{
			name:      "ID doesn't exist",
			id:        "alpha",
			tableRows: []userTableRow{},
			hasErr:    true,
		},
		{
			name: "ID found",
			id:   "alpha",
			tableRows: []userTableRow{
				{
					id:           "alpha",
					email:        "alpha@example.com",
					name:         "Alpha",
					lastSignedIn: ptr.Time(must.Time(t, "2017-05-01T08:02:16-07:00")),
					createdAt:    ptr.Time(must.Time(t, "2017-05-01T08:02:16-07:00")),
					updatedAt:    ptr.Time(must.Time(t, "2017-05-01T08:02:16-07:00")),
				},
			},
			hasErr: false,
			expUser: entity.User{
				ID:             "alpha",
				Name:           "Alpha",
				Email:          "alpha@example.com",
				LastSignedInAt: ptr.Time(must.Time(t, "2017-05-01T08:02:16-07:00")),
				CreatedAt:      ptr.Time(must.Time(t, "2017-05-01T08:02:16-07:00")),
				UpdatedAt:      ptr.Time(must.Time(t, "2017-05-01T08:02:16-07:00")),
			},
		},
		{
			name: "nil time",
			id:   "alpha",
			tableRows: []userTableRow{
				{
					id:           "alpha",
					email:        "alpha@example.com",
					name:         "Alpha",
					lastSignedIn: nil,
					createdAt:    nil,
					updatedAt:    nil,
				},
			},
			hasErr: false,
			expUser: entity.User{
				ID:             "alpha",
				Name:           "Alpha",
				Email:          "alpha@example.com",
				LastSignedInAt: nil,
				CreatedAt:      nil,
				UpdatedAt:      nil,
			},
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			dbtest.AccessTestDB(
				dbConnector,
				dbMigrationTool,
				dbMigrationRoot,
				db


ray = [99; 128];
    let small_vec: SmallVec<[u8; 128]> = SmallVec::from(array);
    assert_eq!(&*small_vec, vec![99u8; 128].as_slice());
    drop(small_vec);
}

#[test]
fn test_from_slice() {
    assert_eq!(&SmallVec::<[u32; 2]>::from_slice(&[1][..])[..], [1]);
    assert_eq!(
        &SmallVec::<[u32; 2]>::from_slice(&[1, 2, 3][..])[..],
        [1, 2, 3]
    );
}

#[test]
fn test_exact_size_iterator() {
    let mut vec = SmallVec::<[u32; 2]>::from(&[1, 2, 3][..]);
    assert_eq!(vec.clone().into_iter().len(), 3);
    assert_eq!(vec.drain(..2).len(), 2);
    assert_eq!(vec.into_iter().len(), 1);
}

#[test]
fn test_into_iter_as_slice() {
    let vec = SmallVec::<[u32; 2]>::from(&[1, 2, 3][..]);
    let mut iter = vec.clone().into_iter();
    assert_eq!(iter.as_slice(), &[1, 2, 3]);
    assert_eq!(iter.as_mut_slice(), &[1, 2, 3]);
    iter.next();
    assert_eq!(iter.as_slice(), &[2, 3]);
    assert_eq!(iter.as_mut_slice(), &[2, 3]);
    iter.next_back();
    assert_eq!(iter.as_slice(), &[2]);
    assert_eq!(iter.as_mut_slice(), &[2]);
}

#[test]
fn test_into_iter_clone() {
    // Test that the cloned iterator yields identical elements and that it owns its own copy
    // (i.e. no use after move errors).
    let mut iter = SmallVec::<[u8; 2]>::from_iter(0..3).into_iter();
    let mut clone_iter = iter.clone();
    while let Some(x) = iter.next() {
        assert_eq!(x, clone_iter.next().unwrap());
    }
    assert_eq!(clone_iter.next(), None);
}

#[test]
fn test_into_iter_clone_partially_consumed_iterator() {
    // Test that the cloned iterator only contains the remaining elements of the original iterator.
    let mut iter = SmallVec::<[u8; 2]>::from_iter(0..3).into_iter().skip(1);
    let mut clone_iter = iter.clone();
    while let Some(x) = iter.next() {
        assert_eq!(x, clone_iter.next().unwrap());
    }
    assert_eq!(clone_iter.next(), None);
}

#[test]
fn test_into_iter_clone_empty_smallvec() {
    let mut iter = SmallVec::<[u8; 2]>::new().into_iter();
    let mut clone_iter = iter.clone();
    assert_eq!(iter.next(), None);
    assert_eq!(clone_iter.next(), None);
}

#[test]
fn shrink_to_fit_unspill() {
    let mut vec = SmallVec::<[u8; 2]>::from_iter(0..3);
    vec.pop();
    assert!(vec.spilled());
    vec.shrink_to_fit();
    assert!(!vec.spilled(), "shrink_to_fit will un-spill if possible");
}

#[test]
fn test_into_vec() {
    let vec = SmallVec::<[u8; 2]


if (typeof header !== "string") {
        throw new TypeError("content-type header is missing from object");
      }
      return header;
    }
    function qstring(val) {
      var str2 = String(val);
      if (TOKEN_REGEXP.test(str2)) {
        return str2;
      }
      if (str2.length > 0 && !TEXT_REGEXP.test(str2)) {
        throw new TypeError("invalid parameter value");
      }
      return '"' + str2.replace(QUOTE_REGEXP, "\\$1") + '"';
    }
    function ContentType(type) {
      this.parameters = /* @__PURE__ */ Object.create(null);
      this.type = type;
    }
  }
});

// node_modules/parseurl/index.js
var require_parseurl = __commonJS({
  "node_modules/parseurl/index.js"(exports, module2) {
    "use strict";
    var url = require("url");
    var parse3 = url.parse;
    var Url = url.Url;
    module2.exports = parseurl;
    module2.exports.original = originalurl;
    function parseurl(req) {
      var url2 = req.url;
      if (url2 === void 0) {
        return void 0;
      }
      var parsed = req._parsedUrl;
      if (fresh(url2, parsed)) {
        return parsed;
      }
      parsed = fastparse(url2);
      parsed._raw = url2;
      return req._parsedUrl = parsed;
    }
    function originalurl(req) {
      var url2 = req.originalUrl;
      if (typeof url2 !== "string") {
        return parseurl(req);
      }
      var parsed = req._parsedOriginalUrl;
      if (fresh(url2, parsed)) {
        return parsed;
      }
      parsed = fastparse(url2);
      parsed._raw = url2;
      return req._parsedOriginalUrl = parsed;
    }
    function fastparse(str2) {
      if (typeof str2 !== "string" || str2.charCodeAt(0) !== 47) {
        return parse3(str2);
      }
      var pathname = str2;
      var query2 = null;
      var search2 = null;
      for (var i = 1; i < str2.length; i++) {
        switch (str2.charCodeAt(i)) {
          case 63:
            if (search2 === null) {
              pathname = str2.substring(0, i);
              query2 = str2.substring(i + 1);
              search2 = str2.substring(i);
            }
            break;
          case 9:
          case 10:
          case 12:
          case 13:
          case 32:
          case 35:
          case 160:
          case 65279:
            return parse3(str2);
        }
      }
      var url2 = Url !== void 0 ? new Url() : {};
      url2.path = str2;
      url2.href = str2;
      url2.pathname = pathname;
      if (search2 !== null) {
        url2.query = query2;
        url2.search = search2;
      }
      return url2;
    }
    function fresh(url2, parsedUrl) {
      return typeof parsedUrl === "object" && parsedUrl !== null && (Url === void 0 || parsedUrl instanceof Url) && parsedUrl._raw === url2;
    }
  }
});

// node_modules/fresh/index.js
var require_fresh = __commonJS({
  "node_modules/fresh/index.js"(exports, module2) {
    "use strict";
    var CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/;
    module2.exports = fresh;
    function fresh(reqHeaders, resHeaders) {
      var modifiedSince = reqHeaders["if-modified-since"];
      var noneMatch = reqHeaders["if-none-match"];
      if (!modifiedSince && !noneMatch) {
        return false;
      }
      var cacheControl = req


/*
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <pj/ctype.h>

/*
char pj_hex_digits[] = {'0', '1', '2', '3', '4', '5', '6', '7',
                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
*/

int pjlib_ctype_c_dummy_symbol;


 it.message }
}package moe.haruue.test.fontprovider

import android.Manifest
import android.annotation.SuppressLint
import android.app.Activity
import android.app.AlertDialog
import android.content.Intent
import android.content.pm.PackageManager
import android.graphics.Typeface
import android.net.Uri
import android.os.Build
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main_content.*
import moe.shizuku.fontprovider.FontProviderClient
import moe.shizuku.fontprovider.FontProviderClient.FontProviderAvailability
import moe.shizuku.fontprovider.compat.TypefaceCompat

class MainActivity : Activity() {

    var init: Boolean = false

    @SuppressLint("SetTextI18n")
    override fun onCreate(savedInstanceState: Bundle?) {
        // replace at Activity, only need call once
        if (!init && !App.createInApplication) {
            if (FontProviderClient.checkAvailability(this) == FontProviderAvailability.OK) {
                App.replace(FontProviderClient.create(this)!!)

                init = true
            }
        }

        // only need request permission on 23
        if (Build.VERSION.SDK_INT == 23
                && checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(arrayOf(Manifest.permission.READ_EXTERNAL_STORAGE), 0)
        }

        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        downloadButton.setOnClickListener {
            val intent = with(Intent(Intent.ACTION_VIEW)) {
                data = Uri.parse("https://github.com/RikkaApps/FontProvider/releases/latest")
                this
            }
            startActivity(intent)
        }
        dialogButton.setOnClickListener {
            val dialog = with(AlertDialog.Builder(this@MainActivity)) {
                setTitle(getString(R.string.it_s_rikka))
                setMessage(R.string.rikka)
                setPositiveButton(R.string.ok) { _, _ -> }
                setNegativeButton(R.string.cancel) { _, _ -> }
                create()
            }
            dialog.show()
        }
        recreateButton.setOnClickListener { recreate() }
        p13.text = "盯~ \uD83D\uDE36\uD83D\uDE36\uD83D\uDE36\uD83D\uDE36"
        p14.text = "盯~ \uD83D\uDE36\uD83D\uDE36\uD83D\uDE36\uD83D\uDE36"

        /**
         * To use your custom font (especially weight is not 400) from assets and get correct weigh
         * of other language, you should use TypefaceCompat.createWeightAlias to create Typeface
         * with weight first.
         * Or fonts for will always 400 weight which is very disappointing. (on pre-Oreo)
         */
        h2.typeface = TypefaceCompat.createWeightAlias(Typeface.createFromAsset(assets, "OpenSans-Light.ttf"), 100)
        h2.text = getString(R.string.h2) + " \uD83D\uDE36\uD83D\uDE36\uD83D\uDE36\uD83D\uDE36"
    }
}
package moe.shizuku.manager

import android.app.Application
import android.content.Context
import android.os.Build
import androidx.appcompat.app.AppCompatDelegate
import com.topjohnwu.superuser.Shell
import moe.shizuku.manager.ktx.logd
import org.lsposed.hiddenapibypass.HiddenApiBypass
import rikka.core.util.BuildUtils.atLeast30
import rikka.material.app.LocaleDelegate

lateinit var application: ShizukuApplication

class ShizukuApplication : Application() {

    companion object {

        init {
            logd("ShizukuApplication", "init")

            Shell.setDefaultBuilder(Shell.Builder.create().setFlags(Shell.FLAG_REDIRECT_STDERR))
            if (Build.VERSION.SDK_INT >= 28) {
                HiddenApiBypass.setHiddenApiExemptions("")
            }
            if (atLeast30) {
                System.loadLibrary("adb")


    .flatpickr-day:not(.today):hover {
        border-width: 0;
    }
}

/* Kanban Autocomplete Fix */
.kanban-plugin__autocomplete-item-active em {
    color: var(--text-on-accent);
}

/* Kanban Callout Fix */
.kanban-plugin__item .callout {
    margin-top: .66em;
}

.kanban-plugin__item .callout-fold,
.kanban-plugin__item .callout-icon {
    display: none;
}

/* Kanban conditional settings */
.setting-item[data-id="anp-kanban-hide-card-menus"]:not(:has(.is-enabled))+[data-id="anp-kanban-hide-archive-btn"] {
    display: none;
}[data-scope='tabs'][data-part='root'] {
	@apply w-full max-w-lg mx-auto;
}

[data-scope='tabs'][data-part='list'] {
	@apply inline-flex h-10 items-center justify-center rounded-md bg-muted p-1 text-muted-foreground;
}

[data-scope='tabs'][data-part='trigger'] {
	@apply inline-flex items-center justify-center whitespace-nowrap rounded-sm px-3 py-1.5 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50;
}

[data-scope='tabs'][data-part='trigger'][data-selected] {
	@apply bg-background text-foreground shadow-sm;
}

[data-scope='tabs'][data-part='trigger']:not([data-selected]):hover {
	@apply text-foreground;
}

[data-scope='tabs'][data-part='content'] {
	@apply mt-6 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2;
}

[data-scope='tabs'][data-part='content'] p {
	@apply text-sm text-muted-foreground leading-relaxed p-4 bg-muted/30 rounded-lg;
}
[data-scope='radio-group'][data-part='root'] {
	@apply flex flex-col gap-3 w-full max-w-xs mx-auto;
}

[data-scope='radio-group'][data-part='label'] {
	@apply text-lg font-semibold text-foreground mb-2;
}

[data-scope='radio-group'][data-part='root'] > div {
	@apply space-y-3;
}

[data-scope='radio-group'][data-part='item'] {
	@apply flex flex-row-reverse items-center gap-4 cursor-pointer w-fit;
}

[data-scope='radio-group'][data-part='item-text'] {
	@apply flex-1 text-base font-medium text-foreground select-none;
}

[data-scope='radio-group'][data-part='item-hidden-input'] {
	@apply sr-only;
}

[data-scope='radio-group'][data-part='item-control'] {
	@apply flex items-center justify-center w-5 h-5 bg-background border-2 border-border rounded-full transition-colors;
}

[data-scope='radio-group'][data-part='item-control']:hover {
	@apply border-primary/50;
}

[data-scope='radio-group'][data-part='item'][data-state='checked'] [data-part='item-control'] {
	@apply bg-primary border-primary text-primary-foreground;
}

[data-scope='radio-group'][data-part='item'][data-disabled] {


("a"), new float[] {10, 10}));
    model.addTermAndVector(new TermAndVector(new BytesRef("b"), new float[] {10, 8}));
    model.addTermAndVector(new TermAndVector(new BytesRef("c"), new float[] {9, 10}));
    model.addTermAndVector(new TermAndVector(new BytesRef("d"), new float[] {1, 1}));
    model.addTermAndVector(new TermAndVector(new BytesRef("e"), new float[] {99, 101}));
    model.addTermAndVector(new TermAndVector(new BytesRef("f"), new float[] {-1, 10}));

    Word2VecSynonymProvider synonymProvider = new Word2VecSynonymProvider(model);

    Analyzer a = getAnalyzer(synonymProvider, maxSynonymPerTerm, minAcceptedSimilarity);
    assertAnalyzesTo(
        a,
        "pre a post", // input
        new String[] {"pre", "a", "d", "e", "c", "b", "post"}, // output
        new int[] {0, 4, 4, 4, 4, 4, 6}, // start offset
        new int[] {3, 5, 5, 5, 5, 5, 10}, // end offset
        new String[] {"word", "word", "SYNONYM", "SYNONYM", "SYNONYM", "SYNONYM", "word"}, // types
        new int[] {1, 1, 0, 0, 0, 0, 1}, // posIncrements
        new int[] {1, 1, 1, 1, 1, 1, 1}); // posLenghts
    a.close();
  }

  @Test
  public void synonymExpansion_oneCandidate_shouldBeExpandedWithTopKSynonyms() throws Exception {
    int maxSynonymPerTerm = 2;
    float minAcceptedSimilarity = 0.9f;
    Word2VecModel model = new Word2VecModel(5, 2);
    model.addTermAndVector(new TermAndVector(new BytesRef("a"), new float[] {10, 10}));
    model.addTermAndVector(new TermAndVector(new BytesRef("b"), new float[] {10, 8}));
    model.addTermAndVector(new TermAndVector(new BytesRef("c"), new float[] {9, 10}));
    model.addTermAndVector(new TermAndVector(new BytesRef("d"), new float[] {1, 1}));
    model.addTermAndVector(new TermAndVector(new BytesRef("e"), new float[] {99, 101}));

    Word2VecSynonymProvider synonymProvider = new Word2VecSynonymProvider(model);

    Analyzer a = getAnalyzer(synonymProvider, maxSynonymPerTerm, minAcceptedSimilarity);
    assertAnalyzesTo(
        a,
        "pre a post", // input
        new String[] {"pre", "a", "d", "e", "post"}, // output
        new int[] {0, 4, 4, 4, 6}, // start offset
        new int[] {3, 5, 5, 5, 10}, // end offset
        new String[] {"word", "word", "SYNONYM", "SYNONYM", "word"}, // types
        new int[] {1, 1, 0, 0, 1}, // posIncrements
        new int[] {1, 1, 1, 1, 1}); // posLenghts
    a.close();
  }

  @Test
  public void synonymExpansion_twoCandidates_shouldBothBeExpanded() throws Exception {
    Word2VecModel model = new Word2VecModel(8, 2);
    model.addTermAndVector(new TermAndVector(new BytesRef("a"), new float[] {10, 10}));
    model.addTermAndVector(new TermAndVector(new BytesRef("b"), new float[] {10, 8}));
    model.addTermAndVector(new TermAndVector(new BytesRef("c"), new float[] {9, 10}));
    model.addTermAndVector(new TermAndVector(new BytesRef("d"), new float[] {1, 1}));
    model.addTermAndVector(new TermAndVector(new BytesRef("e"), new float[] {99, 101}));
    model.addTermAndVector(new TermAndVector(new BytesRef("f"), new float[] {1, 10}));
    model.a


      ]);
      expect(outs, [
        {'id': id},
        null,
      ]);
    });
  });
}
import 'dart:js_interop';

import 'package:sqflite_common/sqlite_api.dart';
import 'package:sqflite_common_ffi_web/sqflite_ffi_web.dart';
import 'package:sqflite_common_ffi_web/src/sqflite_ffi_impl_web.dart'
    show SqfliteFfiHandlerWeb;
import 'package:sqflite_common_ffi_web/src/utils.dart';
import 'package:sqflite_common_ffi_web/src/web/load_sqlite_web.dart'
    show
        SqfliteFfiWebContextExt,
        SqfliteFfiWebWorkerException,
        defaultSharedWorkerUri;
import 'package:synchronized/synchronized.dart';
import 'package:web/web.dart' as web;

import 'import.dart';

/// The Ffi database factory.
var databaseFactoryFfiWebNoWebWorkerImpl = () {
  return createDatabaseFactoryFfiWeb(noWebWorker: true);
}();

/// The Ffi database factory with basic worker
var databaseFactoryFfiWebBasicWorkerImpl = () {
  return createDatabaseFactoryFfiWeb(
    // ignore: invalid_use_of_visible_for_testing_member
    options: SqfliteFfiWebOptions(forceAsBasicWorker: true),
  );
}();

/// The Ffi database factory.
var databaseFactoryFfiWebImpl = () {
  return createDatabaseFactoryFfiWeb();
}();

final _initLock = Lock();

/// Creates an FFI database factory
DatabaseFactory createDatabaseFactoryFfiWeb({
  SqfliteFfiWebOptions? options,
  bool noWebWorker = false,
  String? tag,
}) {
  var webOptions = options ??= SqfliteFfiWebOptions();
  SqfliteFfiWebContext? context;
  return buildDatabaseFactory(
    tag: tag ?? 'ffi_web',
    invokeMethod: (String method, [Object? arguments]) async {
      final methodCall = FfiMethodCall(method, arguments);
      if (noWebWorker) {
        if (context == null) {
          await _initLock.synchronized(() async {
            context ??= await sqfliteFfiWebLoadSqlite3Wasm(webOptions);
            sqfliteFfiHandler = SqfliteFfiHandlerWeb(context!);
          });
        }
        return ffiMethodCallHandleNoWebWorker(methodCall, context!);
      } else {
        if (context == null) {
          await _initLock.synchronized(() async {
            context ??= await sqfliteFfiWebStartSharedWorker(webOptions);
            sqfliteFfiHandler = SqfliteFfiHandlerWeb(context!);
          });
        }

        return ffiMethodCallSendToWebWorker(methodCall, context!);
      }
    },
  );
}

// Debug database factory web
bool get _debug => sqliteFfiWebDebugWebWorker;
var _log = print;

/// Handle method call not to call the web worker.
Future<dynamic> ffiMethodCallSendToWebWorker(
  FfiMethodCall methodCall,
  SqfliteFfiWebContext context,
) async {
  try {
    if (_debug) {
      // ignore: avoid_print
      _log('main_send: $methodCall');
    }
    var map = dataToEncodable(methodCall.toDataMap())!;
    var response = await context.sendRawMessage(map);
    if (_debug) {
      _log('main_recv: $response');
    }
    return dataFromEncodable(responseToResultOrThrow(response));
  } catch (e, st) {
    if (_debug) {
      _log(e);
      _log(st);
    }
    if (e is SqfliteFfiWebWorkerException) {


being correct!
	DecompressImage(compressedFormat, outputComp.Ptr(), checkUnc.Ptr(), W, H);

	double sqError = 0;
	for (int i = 0; i < W * H * 4; i++) {
		if (compressedFormat == GL_COMPRESSED_RGB_S3TC_DXT1_EXT && (i % 4) >= 3)
			continue;	// DXT1: no alpha
		if (compressedFormat == GL_COMPRESSED_RG_RGTC2 && (i % 4) >= 2)
			continue;	// RGTC: no blue and alpha
		int delta = idMath::Abs(0 + checkUnc[i] - inputUnc[i]);
		sqError += delta * delta;
	}
	sqError /= (W * H);
	float avgError = idMath::Sqrt(sqError);

#ifdef _DEBUG
#define IMSAVE(varname)	idImageWriter().Source(varname.Ptr(), W, H).Dest(fileSystem->OpenFileWrite("temp_" #varname ".tga")).WriteTGA();
	if (avgError > maxAvgError) {
		IMSAVE(inputUnc);
		IMSAVE(checkUnc);
	}
#endif

	//compression inevitably results in precision loss
	//we can't do exact comparison, so we do a very basic quality test instead
	CHECK(avgError <= maxAvgError);
}

static idList<byte> GenImageConstant(int W, int H, int R, int G, int B, int A) {
	idList<byte> res;
	res.SetNum(W * H * 4);
	for (int i = 0; i < W*H; i++) {
		res[4 * i + 0] = R;
		res[4 * i + 1] = G;
		res[4 * i + 2] = B;
		res[4 * i + 3] = A;
	}
	return res;
}

static idList<byte> GenImageGradient(int W, int H) {
	idList<byte> res;
	res.SetNum(W * H * 4);
	int pos = 0;
	for (int i = 0; i < H; i++)
		for (int j = 0; j < W; j++) {
			res[pos++] = i * 255 / (H - 1);
			res[pos++] = (W - 1 - j) * 255 / (W - 1);
			res[pos++] = (i + j) * 255 / (H + W - 2);
			res[pos++] = (H - 1 - i + j) * 255 / (H + W - 2);
		}
	return res;
}

static idList<byte> GenImageRandom(int W, int H, idRandom &rnd) {
	idList<byte> res;
	res.SetNum(W * H * 4);
	for (int i = 0; i < res.Num(); i++)
		res[i] = rnd.RandomInt(256);
	return res;
}

static idList<byte> GenImageCopy(int W, int H, const byte *pic) {
	idList<byte> res;
	res.SetNum(W * H * 4);
	memcpy(res.Ptr(), pic, W * H * 4);
	return res;
}

static void TestDecompressDxt(bool checkPerfo) {
	idRandom rnd;
	static const GLenum FORMATS[] = {
		GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
		GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
		GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
		GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
		GL_COMPRESSED_RG_RGTC2,
		0
	};
	for (int f = 0; FORMATS[f]; f++) {
		GLenum format = FORMATS[f];
		if (checkPerfo) {
			//check performance
			TestDecompressOnImage(1024, 1024, GenImageRandom(1024, 1024, rnd), format, true);
		}
		else {
			//check correctness
			TestDecompressOnImage(16, 16, GenImageConstant(16, 16, 255, 255, 255, 255), format);
			TestDecompressOnImage(16, 16, GenImageConstant(16, 16, 100, 128, 127, 197), format);
			Test


"饱经风霜的墓碑", nil, {"去和夜色镇的希拉·沃宁迪谈一谈。"}},
[226] = {"恶狼成群", nil, {"杀掉12只饥饿的恐狼和8只疯狂的恐狼，然后到斯温的营地中向拉尔斯交差。"}},
[227] = {"摩根·拉迪莫尔", nil, {"去和夜色镇的指挥官阿尔泰娅·埃伯洛克谈一谈。"}},
[228] = {"摩拉迪姆", nil, {"杀掉摩拉迪姆，把他的头骨交给夜色镇的指挥官阿尔泰娅·埃伯洛克。"}},
[229] = {"幸存的女儿", nil, {"去和夜色镇的守夜人莎拉·拉迪莫尔谈一谈。"}},
[230] = {"斯温的营地", nil, {"把你从斯温的农场找到的书交给他。"}},
[231] = {"女儿的爱", nil, {"把莎拉·拉迪莫尔的戒指拿到摩根·拉迪莫尔的坟墓上去。"}},
[232] = {"金格的货物", nil, {"把订货单交给幽暗城的奥雷萨多·卢卡。"}},
[233] = {"寒脊山谷的送信任务", nil, {"把这一摞信件送给寒脊山谷的塔林·锐眼。"}},
[234] = {"寒脊山谷的送信任务", nil, {"把这封信送给寒脊山谷的格瑞林·白须。"}},
[235] = {"灰谷狩猎", nil, {"与灰谷碎木哨岗的塞娜尼·雷心谈一谈。"}},
[236] = {"战车的燃料", nil, {"冬拥堡垒的攻城大师斯托汉德要你前往烈焰之坑，收集10份永恒灰烬。"}},
[237] = {"保卫国王的领土", nil, {"南部警戒塔的巡山人格拉维戈要你杀掉10个碎石怪击颅者和10个碎石怪先知，然后回去向他汇报。"}},
[238] = {"金格的货物", nil, {"把采样工具包交给幽暗城的药剂师金格。"}},
[239] = {"西泉要塞", nil, {"到西泉要塞去和瑞尼尔副队长谈一谈。"}},
[240] = {"基特斯的美餐", nil, {"把黑蟹蛋糕拿回去交给基特斯。"}},
[241] = {"<TEST> HEY MISTER WILSON


//===----------------------------------------------------------------------===//
// Distributed under the 3-Clause BSD License. See accompanying file LICENSE or
// copy at https://opensource.org/licenses/BSD-3-Clause.
// SPDX-License-Identifier: BSD-3-Clause
//===----------------------------------------------------------------------===//

#pragma once

#include <Oxygen/Base/NoStd.h>

namespace oxygen {

template <typename T> struct Point {
  T x;
  T y;

  friend auto to_string(Point const& self)
  {
    std::string out = "x: ";
    out.append(nostd::to_string(self.x));
    out.append(", y: ");
    out.append(nostd::to_string(self.y));
    return out;
  }
};

template <typename T> struct Extent {
  T width;
  T height;

  friend auto to_string(Extent const& self)
  {
    std::string out = "w: ";
    out.append(nostd::to_string(self.width));
    out.append(", h: ");
    out.append(nostd::to_string(self.height));
    return out;
  }
};

template <typename T> struct Bounds {
  // Upper left corner
  Point<T> origin;
  // Width and height
  Extent<T> extent;

  friend auto to_string(Bounds const& self)
  {
    std::string out = "x: ";
    out.append(nostd::to_string(self.origin.x));
    out.append(", y: ");
    out.append(nostd::to_string(self.origin.y));
    out.append(", w: ");
    out.append(nostd::to_string(self.extent.width));
    out.append(", h: ");
    out.append(nostd::to_string(self.extent.height));
    return out;
  }
};

template <typename T> struct Motion {
  T dx;
  T dy;

  friend auto to_string(Motion const& self)
  {
    std::string out = "dx: ";
    out.append(nostd::to_string(self.dx));
    out.append(", dy: ");
    out.append(nostd::to_string(self.dy));
    return out;
  }
};

using PixelPosition = Point<int>;
using SubPixelPosition = Point<float>;
using PixelExtent = Extent<int>;
using SubPixelExtent = Extent<float>;
using PixelBounds = Bounds<int>;
using SubPixelBounds = Bounds<float>;
using PixelMotion = Motion<int>;
using SubPixelMotion = Motion<float>;

struct Axis1D {
  float x;

  friend auto to_string(Axis1D const& self)
  {
    std::string out = "x: ";
    out.append(nostd::to_string(self.x));
    return out;
  }
};
struct Axis2D {
  float x;
  float y;

  friend auto to_string(Axis2D const& self)
  {
    std::string out = "x: ";
    out.append(nostd::to_string(self.x));
    out.append(", y: ");
    out.append(nostd::to_string(self.y));
    return out;
  }
};

} // namespace oxygen


LimeTypeAlias> = emptyList(),
    val functions: List<LimeFunction> = emptyList(),
    val properties: List<LimeProperty> = emptyList(),
    val exceptions: List<LimeException> = emptyList(),
    val classes: List<LimeClass> = emptyList(),
    val interfaces: List<LimeInterface> = emptyList(),
    val lambdas: List<LimeLambda> = emptyList(),
) : LimeType(path, comment, attributes, external) {
    val constructors
        get() = functions.filter { it.isConstructor }
}
/*
 * Copyright (C) 2016-2019 HERE Europe B.V.
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */

package com.here.gluecodium.model.lime

abstract class LimeTypeRef(attributes: LimeAttributes? = null) : LimeElementRef<LimeType>(attributes) {
    abstract val type: LimeType
    abstract val isNullable: Boolean

    abstract fun asNullable(): LimeTypeRef

    override fun remap(referenceMap: Map<String, LimeElement>): LimeTypeRef = this

    override val element
        get() = type

    override fun toString() = type.name + if (isNullable) "?" else ""
}
/*
 * Copyright (C) 2016-2019 HERE Europe B.V.
 *
 * 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.
 *
 * SPDX-License-Identifier: Apache-2.0
 * License-Filename: LICENSE
 */

package com.here.gluecodium.model.lime

/**
 * An ambiguous reference to a type, represented by [relativePath]. The ambiguity is resolved
 * through the [LimeAmbiguityResolver].
 *
 * The resolution logic is "lazy": if it succeeds on the first call then the result is stored and the
 * stored result is used on subsequent calls instead.
 */
class LimeAmbiguousTypeRef(
    private val relativePath: List<String>,
    private val parentPaths: List<LimePath>,
    private val imports: List<LimePath>,
    private val referenceMap: Map<String, LimeElement>,
    override val isNullable: Boolean = false,
    attributes: LimeAttributes? = null,
) : LimeTypeRef(attributes) {
    override val type by lazy {
        LimeAmbiguityResolver.resolve<LimeType>(relativePath, parentPaths, imports, referenceMap)
    }

    override fun asNullable() =
        when {
            isNullable -> this
            else -> LimeAmbiguousTypeRef(relativePath, parentPaths, imports, referenceMap, true, attributes)
        }

    override fun remap(referenceMap: Map<String, LimeElement>) =
        LimeAmbiguousTypeRef(relativePath, parentPaths, imports, referenceMap, isNullable, attributes)
}
/*
 * Copyright (C) 2019-2025 HERE Europe B.V.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance


    }

    fun getStringTagList(list: NBTTagCompound, key: String): NBTTagList {
        //#if MC < 1.21
        return list.getTagList(key, TAG_STRING)
        //#else
        //$$ val nbtList = list.getList(key).getOrNull() ?: NbtList()
        //$$ return getList(nbtList, TAG_STRING)
        //#endif
    }

    fun getCompoundTagList(list: NBTTagCompound, key: String): NBTTagList {
        //#if MC < 1.21
        return list.getTagList(key, TAG_COMPOUND)
        //#else
        //$$ val nbtList = list.getList(key).getOrNull() ?: NbtList()
        //$$ return getList(nbtList, TAG_COMPOUND)
        //#endif
    }

    //#if MC > 1.21
    //$$ private fun getList(list: NbtList, type: Int): NbtList {
    //$$     for (nbtElement in list) {
    //$$         when (type) {
    //$$             TAG_STRING -> if (nbtElement !is NbtString) return NbtList()
    //$$             TAG_COMPOUND -> if (nbtElement !is NbtCompound) return NbtList()
    //$$             TAG_INT -> if (nbtElement !is NbtInt) return NbtList()
    //$$             TAG_DOUBLE -> if (nbtElement !is NbtDouble) return NbtList()
    //$$             TAG_LONG -> if (nbtElement !is NbtLong) return NbtList()
    //$$             TAG_BYTE -> if (nbtElement !is NbtByte) return NbtList()
    //$$             TAG_FLOAT -> if (nbtElement !is NbtFloat) return NbtList()
    //$$         }
    //$$     }
    //$$     return list
    //$$ }
    //#endif
}

//#if MC > 1.21
//$$
//$$ fun NbtCompound.getStringOrDefault(key: String): String {
//$$     return this.getString(key).getOrNull() ?: ""
//$$ }
//$$
//$$ fun NbtCompound.getIntOrDefault(key: String?): Int {
//$$     return this.getInt(key).getOrNull() ?: 0
//$$ }
//$$
//$$ fun NbtCompound.getLongOrDefault(key: String): Long {
//$$     return this.getLong(key).getOrNull()  ?: 0
//$$ }
//$$
//$$ fun NbtCompound.getFloatOrDefault(key: String): Float {
//$$     return this.getFloat(key).getOrNull() ?: 0f
//$$ }
//$$
//$$ fun NbtCompound.getDoubleOrDefault(key: String): Double {
//$$     return this.getDouble(key).getOrNull() ?: 0.0
//$$ }
//$$
//$$ fun NbtCompound.getBooleanOrDefault(key: String): Boolean {
//$$     return this.getBoolean(key).getOrNull()  ?: false
//$$ }
//$$
//$$ fun NbtCompound.getByteOrDefault(key: String): Byte? {
//$$     return this.getByte(key).getOrNull()
//$$ }
//$$
//$$ fun NbtCompound.getCompoundOrDefault(key: String): NbtCompound {
//$$     if (this.getCompound(key).isEmpty) {
//$$         return NbtCompound()
//$$     }
//$$     return this.getCompound(key).get()
//$$ }
//$$
//$$ fun NbtList.getStringOrDefault(index: Int): String {
//$$     return this.getString(index).getOrNull() ?: ""
//$$ }
//$$
//$$ fun NbtList.getCompoundOrDefault(index: Int): NbtCompound {
//$$     return this.getCompound(index).getOrNull() ?: NbtCompound()
//$$ }
//#endif
package at.hannibal2.skyhanni.utils.shader

import at.hannibal2.skyhanni.utils.ChatU


llowance)

		// Sending 4001 should fail.
		transfer = new(big.Int).Mul(big.NewInt(4001), params.DecimalFactor)
		_, err = liquidState.TransferFrom(
			FromSender(delegatorC, nil), delegatorA, delegatorB, transfer,
		)
		require.Error(r.T, err)
		require.Equal(r.T, "execution reverted: ERC20: transfer amount exceeds allowance", err.Error())
	})

	r.Run("locking", func(r *Runner) {
		balance := new(big.Int).Mul(big.NewInt(10000), params.DecimalFactor)
		balanceToLock := new(big.Int).Mul(big.NewInt(1000), params.DecimalFactor)
		// increment := new(big.Int).Mul(big.NewInt(100), params.DecimalFactor)

		// mint
		r.NoError(
			liquidState.Mint(
				FromAutonity, delegatorA, balance,
			),
		)
		checkLiquidBalance(r, liquidState, delegatorA, balance)
		checkLockedLiquidBalance(r, liquidState, delegatorA, common.Big0)

		// lock more than balance
		_, err = liquidState.Lock(
			FromAutonity, delegatorA, new(big.Int).Add(balance, common.Big1),
		)
		require.Error(r.T, err)
		require.Equal(r.T, "execution reverted: can't lock more funds than available", err.Error())

		// lock less than balance
		r.NoError(
			liquidState.Lock(
				FromAutonity, delegatorA, balanceToLock,
			),
		)
		checkLockedLiquidBalance(r, liquidState, delegatorA, balanceToLock)
		checkLiquidBalance(r, liquidState, delegatorA, balance)

		maxTransferable := new(big.Int).Sub(balance, balanceToLock)
		// transfer more than unlocked
		_, err = liquidState.Transfer(
			FromSender(delegatorA, nil), delegatorB, new(big.Int).Add(maxTransferable, common.Big1),
		)
		require.Error(r.T, err)
		require.Equal(r.T, "execution reverted: insufficient unlocked funds", err.Error())

		// burn more than unlocked
		_, err = liquidState.Burn(
			FromAutonity, delegatorA, new(big.Int).Add(maxTransferable, common.Big1),
		)
		require.Error(r.T, err)
		require.Equal(r.T, "execution reverted: insufficient unlocked funds", err.Error())

		// cannot unlock more than locked
		_, err = liquidState.Unlock(
			FromAutonity, delegatorA, new(big.Int).Add(maxTransferable, common.Big1),
		)
		require.Error(r.T, err)
		require.Equal(r.T, "execution reverted: can't unlock more funds than locked", err.Error())

		// unlock
		r.NoError(
			liquidState.Unlock(
				FromAutonity, delegatorA, balanceToLock,
			),
		)
		checkLiquidBalance(r, liquidState, delegatorA, balance)
		checkLockedLiquidBalance(r, liquidState, delegatorA, common.Big0)

		// transfer and burn whole amount
		transferAmount := new(big.Int).Add(maxTransferable, common.Big1)
		burnAmount := new(big.Int).Sub(balance, transferAmount)
		r.NoError(
			liquidState.Transfer(
				FromSender(delegatorA, nil), delegatorB, transferAmount,
			),
		)
		checkLiquidBalance(r, liquidState, delegatorA, burnAmount)

		r.NoError(
			liquidState.Burn(
				FromAutonity, delegatorA, burnAmount,
			),
		)
		checkLiquidBal


siveUpperBound(filter_created_at) => {
                                if created_at.0 > *filter_created_at.end() {
                                    continue;
                                }
                                *filter_created_at.start()
                            }
                        };
                        if let Some(first_created_at) = first_created_at_filtered {
                            debug_assert!(first_created_at <= filter_created_at_start);
                            if created_at.0 < first_created_at {
                                continue;
                            }
                        }
                        if created_at.0 <= filter_created_at_start {
                            first_created_at_filtered = Some(created_at.0);
                        }
                    }
                    let size_in_bytes = path.metadata()?.len();
                    entries.push(RollingFileInfoWithSize {
                        path,
                        created_at,
                        size_in_bytes,
                    });
                    continue;
                }
            }
            log::debug!("Ignoring directory entry {}", path.display());
        }
        if let Some(first_created_at_filtered) = first_created_at_filtered {
            // Post-process filter
            entries.retain(|file_info| file_info.created_at.0 >= first_created_at_filtered);
        }
        Ok(entries)
    }

    /// Read all entries in the base path directory, sorted by _created at_ in ascending order
    pub fn read_all_dir_entries_filtered_chronologically(
        &self,
        filter: &FileInfoFilter,
    ) -> IoResult<Vec<RollingFileInfoWithSize>> {
        let mut entries = self.read_all_dir_entries_filtered(filter)?;
        entries.sort_unstable_by(RollingFileInfoWithSize::cmp_created_at);
        Ok(entries)
    }

    pub fn read_most_recent_dir_entry(&self) -> IoResult<Option<RollingFileInfoWithSize>> {
        Ok(self
            .read_all_dir_entries_filtered_chronologically(&FileInfoFilter {
                created_at: Some(SystemTimeRange::OnlyMostRecent),
            })?
            .into_iter()
            .last())
    }
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct RollingFileConfig {
    pub system: RollingFileSystem,
    pub limits: RollingFileLimits,
}

#[cfg(test)]
mod tests;
<gh_stars>10-100
use ::{BroadcastMode, Instruction, MaskReg, MergeMode, Mnemonic, OperandSize, Reg, RoundingMode};
use ::RegType::*;
use ::instruction_def::*;
use ::Operand::*;
use ::Reg::*;
use ::RegScale::*;
use ::test::run_test;

#[test]
fn fucom_1() {
    run_test(&Instruction { mnemonic: Mnemonic::FUCOM, operand1: Some(Direct(ST5)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[221, 229], OperandSize::Word)
}

#[test]
fn fucom_2() {
    run_test(&Instruction { mnemonic: Mnemonic::FUCOM, operand1: Some(Direct(ST6)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[221, 230], OperandSize::Dword)
}

#[test]
fn fucom_3() {
    run_test(&Instruction { mnemonic: Mnemonic::FUCOM, operand1: Some(Direct(ST1)), operand2: None, operand3: None, operand4: None, lock: false, rounding_mode: None, merge_mode: None, sae: false, mask: None, broadcast: None }, &[221, 225], OperandSize::Qword)
}

<filename>src/lib.rs<gh_stars>0
#![feature(
    dropck_eyepatch, // Needed to bypass dropchk
    allocator_api, //


CodeHandlerKind.EV_REXW_1A:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Ev_REXW(code, Code.INVALID, deserializer.readInt32());
			break;

		case LegacyOpCodeHandlerKind.EV_REXW:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Ev_REXW(code, code + 1, deserializer.readInt32());
			break;

		case LegacyOpCodeHandlerKind.EV_SW:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Ev_Sw(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.EV_VX:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Ev_VX(code, code + 1);
			break;

		case LegacyOpCodeHandlerKind.EV1:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Ev_1(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.EVJ:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Evj(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.EVW:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Evw(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.EW:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Ew(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.GB_EB:
			elem = new OpCodeHandler_Gb_Eb(deserializer.readCode());
			break;

		case LegacyOpCodeHandlerKind.GDQ_EV:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Gdq_Ev(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.GV_EB:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Gv_Eb(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.GV_EB_REX:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Gv_Eb_REX(code, code + 1);
			break;

		case LegacyOpCodeHandlerKind.GV_EV_32_64:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Gv_Ev_32_64(code, code + 1, deserializer.readBoolean(), deserializer.readBoolean());
			break;

		case LegacyOpCodeHandlerKind.GV_EV_3A:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Gv_Ev(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.GV_EV_3B:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Gv_Ev(code, code + 1, Code.INVALID);
			break;

		case LegacyOpCodeHandlerKind.GV_EV_IB:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Gv_Ev_Ib(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.GV_EV_IB_REX:
			elem = new OpCodeHandler_Gv_Ev_Ib_REX(code = deserializer.readCode(), code + 1);
			break;

		case LegacyOpCodeHandlerKind.GV_EV_IZ:
			code = deserializer.readCode();
			elem = new OpCodeHandler_Gv_Ev_Iz(code, code + 1, code + 2);
			break;

		case LegacyOpCodeHandlerKind.GV_EV_REX:
			code = deserializer.readCode();
			elem = new OpCodeHandler


ldrb r0, [r7, #4]
	tst r0, #3
	ldmneia sp!, {r4, r5, r6, r7, r8, sb, sl, pc}
	ldr r4, [r7, #0xb8]
	add r6, r7, #0xb8
	cmp r4, #0
	beq _0207484C
	ldr r8, _02074858 ; =DRIVER_WORK
	mvn sl, #0
	mov sb, #0
_0207480C:
	ldmib r4, {r0, r5}
	cmp r0, #0
	strgt r4, [r6]
	addgt r6, r4, #8
	bgt _02074840
	mov r0, r7
	mov r1, r4
	bl DseChannel_ReleaseNoteInternal
	ldr r0, [r8, #0x650]
	str r0, [r4, #8]
	str r4, [r8, #0x650]
	str sl, [r4, #4]
	strb sb, [r4, #1]
_02074840:
	mov r4, r5
	cmp r5, #0
	bne _0207480C
_0207484C:
	mov r0, #0
	str r0, [r6]
	ldmia sp!, {r4, r5, r6, r7, r8, sb, sl, pc}
	.align 2, 0
_02074858: .word DRIVER_WORK
	arm_func_end DseVoice_ReleaseHeld

	arm_func_start DseVoice_Release
DseVoice_Release: ; 0x0207485C
	stmdb sp!, {r4, lr}
	mov r4, r1
	ldrh r1, [r4, #4]
	orr r1, r1, #2
	strh r1, [r4, #4]
	ldrb r0, [r0, #4]
	tst r0, #1
	ldmneia sp!, {r4, pc}
	ldr r1, [r4, #0x14c]
	add r0, r4, #0x3c
	and r1, r1, #0xff
	str r1, [r4, #0x14c]
	bl SoundEnvelope_Release
	ldrh r0, [r4, #6]
	bic r0, r0, #1
	strh r0, [r4, #6]
	ldmia sp!, {r4, pc}
	arm_func_end DseVoice_Release

	arm_func_start DseVoice_Deallocate
DseVoice_Deallocate: ; 0x020748A0
	stmdb sp!, {r4, lr}
	mov r4, r0
	ldr r1, [r4, #0x158]
	cmp r1, #0
	beq _02074948
	ldr r2, [r1, #0xb4]
	cmp r2, r4
	ldreq r0, [r4, #0x154]
	streq r0, [r1, #0xb4]
	beq _020748F0
	cmp r2, #0
	beq _020748F0
_020748D0:
	ldr r0, [r2, #0x154]
	cmp r0, r4
	ldreq r0, [r4, #0x154]
	streq r0, [r2, #0x154]
	beq _020748F0
	mov r2, r0
	cmp r0, #0
	bne _020748D0
_020748F0:
	mov r0, #0
	strh r0, [r4, #4]
	str r0, [r4, #0x158]
	str r0, [r4, #0x154]
	add


ell Deflection (NYI)']={t=1000,icon='Temp'},
  ['Spice Mortar']={t=500,icon='Spell_Fire_Fireball02'},
  ['Spike Volley']={t=500,icon='Ability_ImpalingBolt'},
  ['Spirit Decay']={t=2000,icon='Spell_Holy_HarmUndeadAura'},
  ['Spirit Spawn-out']={t=500,icon='Temp'},
  ['Spirit Steal']={t=2000,icon='Spell_Shadow_Possession'},
  ['Spotted Frostsaber']={t=3000,icon='Ability_Mount_WhiteTiger'},
  ['Spotted Panther']={t=3000,icon='Ability_Mount_BlackPanther'},
  ['Sprinkling Purified Water']={t=6000,icon='Temp'},
  ['Starfire']={t=3500,icon='Spell_Arcane_StarFire'},
  ['Steel Mechanostrider']={t=3000,icon='Ability_Mount_MechaStrider'},
  ['Stone Dwarf Awaken Visual']={t=1500,icon='Spell_Nature_Earthquake'},
  ['Stoned - Channel Cast Visual']={t=3000,icon='Spell_Nature_Cyclone'},
  ['Stoneskin']={t=6000,icon='Spell_Nature_EnchantArmor'},
  ['Stonesplinter Trogg Disguise']={t=3000,icon='Ability_Rogue_Disguise'},
  ['Storm Bolt']={t=1000,icon='INV_Hammer_01'},
  ['Stormpike Battle Charger']={t=3000,icon='Ability_Mount_MountainRam'},
  ['Strength of Arko\'narin']={t=4000,icon='Spell_Nature_AstralRecal'},
  ['Strength of the Ages']={t=2000,icon='Spell_Shadow_Requiem'},
  ['Strike']={t=2000,icon='Temp'},
  ['Striped Frostsaber']={t=3000,icon='Ability_Mount_WhiteTiger'},
  ['Striped Nightsaber']={t=3000,icon='Ability_Mount_BlackPanther'},
  ['Stuck']={t=10000,icon='Spell_Shadow_Teleport'},
  ['Stun Bomb']={t=2000,icon='Spell_Fire_SelfDestruct'},
  ['Stun Bomb Attack']={t=2000,icon='Spell_Fire_SelfDestruct'},
  ['Submerge Visual']={t=1500,icon='Spell_Fire_Volcano'},
  ['Summon']={t=1000,icon='Spell_Arcane_Blink'},
  ['Summon Alarm-o-Bot']={t=250,icon='INV_Gizmo_08'},
  ['Summon Albino Snake']={t=1000,icon='Ability_Seal'},
  ['Summon Albino Snapjaw']={t=1000,icon='Ability_Seal'},
  ['Summon Ancient Spirits']={t=2000,icon='Temp'},
  ['Summon Ancona']={t=1000,icon='Ability_Seal'},
  ['Summon Aquementas']={t=2000,icon='Temp'},
  ['Summon Ar\'lia']={t=2500,icon='Spell_Nature_GroundingTotem'},
  ['Summon Atal\'ai Skeleton']={t=1000,icon='Spell_Shadow_RaiseDead'},
  ['Summon Azure Whelpling']={t=1000,icon='Ability_Seal'},
  ['Summon Baby Shark']={t=1000,icon='Ability_Seal'},
  ['Summon Black Kingsnake']={t=1000,icon='Ability_Seal'},
  ['Summon Black Qiraji Battle Tank']={t=3000,icon='INV_Misc_QirajiCrystal_05'},
  ['Summon Blackhand Dreadweaver']={t=5000,icon='Spell_Nature_Purge'},
  ['Summon Blackhand Veteran']={t=5000,icon='Spell_Nature_Purge'},
  ['Summon Blood Parrot']={t=1000,icon='


e> unmarked elements exist, then mark all of them.

Return _an array answer of size_ `m` _where_ `answer[i]` _is the **sum** of unmarked elements in the array after the_ ith _query_.

**Example 1:**

**Input:** nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]]

**Output:** [8,3,0]

**Explanation:**

We do the following queries on the array:

*   Mark the element at index `1`, and `2` of the smallest unmarked elements with the smallest indices if they exist, the marked elements now are nums = [**1**,**2**,2,**1**,2,3,1]. The sum of unmarked elements is `2 + 2 + 3 + 1 = 8`.
*   Mark the element at index `3`, since it is already marked we skip it. Then we mark `3` of the smallest unmarked elements with the smallest indices, the marked elements now are nums = [**1**,**2**,**2**,**1**,**2**,3,**1**]. The sum of unmarked elements is `3`.
*   Mark the element at index `4`, since it is already marked we skip it. Then we mark `2` of the smallest unmarked elements with the smallest indices if they exist, the marked elements now are nums = [**1**,**2**,**2**,**1**,**2**,**3**,**1**]. The sum of unmarked elements is `0`.

**Example 2:**

**Input:** nums = [1,4,2,3], queries = [[0,1]]

**Output:** [7]

**Explanation:** We do one query which is mark the element at index `0` and mark the smallest element among unmarked elements. The marked elements will be nums = [**1**,4,**2**,3], and the sum of unmarked elements is `4 + 3 = 7`.

**Constraints:**

*   `n == nums.length`
*   `m == queries.length`
*   1 <= m <= n <= 105
*   1 <= nums[i] <= 105
*   `queries[i].length == 2`
*   0 <= indexi, ki <= n - 13070\. Count Submatrices with Top-Left Element and Sum Less Than k

Medium

You are given a **0-indexed** integer matrix `grid` and an integer `k`.

Return _the **number** of submatrices that contain the top-left element of the_ `grid`, _and have a sum less than or equal to_ `k`.

**Example 1:**

![](https://assets.leetcode.com/uploads/2024/01/01/example1.png)

**Input:** grid = [[7,6,3],[6,6,1]], k = 18

**Output:** 4

**Explanation:** There are only 4 submatrices, shown in the image above, that contain the top-left element of grid, and have a sum less than or equal to 18.

**Example 2:**

![](https://assets.leetcode.com/uploads/2024/01/01/example21.png)

**Input:** grid = [[7,2,9],[1,5,0],[2,6,6]], k = 20

**Output:** 6

**Explanation:** There are only 6 submatrices, shown in the image above


--
-- Created by IntelliJ IDEA.
-- User: chen0
-- Date: 26/7/2017
-- Time: 10:05 AM
-- To change this template use File | Settings | File Templates.
--

local MinPQ = {}
MinPQ.__index = MinPQ

function MinPQ.create(comparator)
    local s = {}
    setmetatable(s, MinPQ)

    if comparator == nil then
        comparator = function(a1, a2) return a1 - a2 end
    end

    s.a = {}
    s.N = 0
    s.comparator = comparator
    return s
end

function MinPQ:add(item)
    self.N = self.N + 1
    self.a[self.N] = item

    self:swim(self.N)
end

function MinPQ:delMin()
    if self.N == 0 then
        return nil
    end

    local item = self.a[1]

    self:exchange(self.a, 1, self.N)
    self.N = self.N - 1
    self:sink(1)

    return item
end

function MinPQ:sink(k)
    while k * 2 <= self.N do
        local ch


(0)).addBatch();

		var count = agent.batch(ctx);
		assertEquals(2, count.length, "データの登録件数が不正です。");
		assertEquals(1, count[0], "1行目のデータの登録に失敗しました。");
		assertEquals(1, count[1], "2行目のデータの登録に失敗しました。");

		var expectedDataList = getDataFromFile(Paths.get(
				"src/test/resources/data/expected/SqlAgent", "testExecuteBatchNull.ltsv"));
		List<Map<String, Object>> actualDataList = agent.query("example/select_product")
				.param("product_id", List.of(1, 2))
				.stream(new MapResultSetConverter(agent.getSqlConfig(), CaseFormat.LOWER_SNAKE_CASE))
				.collect(Collectors.toList());

		assertEquals(expectedDataList.toString(), actualDataList.toString());
	}

	/**
	 * バッチ処理のテストケース(Stream)。
	 */
	@Test
	void testExecuteBatchStream() throws Exception {
		// 事前条件
		truncateTable("PRODUCT");

		// 処理実行
		var input = getDataFromFile(Paths.get("src/test/resources/data/expected/SqlAgent",
				"testExecuteBatchStream.ltsv"));
		var count = agent.batch("example/insert_product").paramStream(input.stream()).count();

		assertEquals(100, count, "データの登録件数が不正です。");

		// 検証処理
		var expectedDataList = getDataFromFile(Paths.get(
				"src/test/resources/data/expected/SqlAgent", "testExecuteBatchStream.ltsv"));
		List<Map<String, Object>> actualDataList = agent.query("example/select_product")
				.stream(new MapResultSetConverter(agent.getSqlConfig(), CaseFormat.LOWER_SNAKE_CASE))
				.collect(Collectors.toList());

		assertEquals(expectedDataList.toString(), actualDataList.toString());
	}

	/**
	 * バッチ処理のテストケース(Stream)。
	 */
	@Test
	void testExecuteBatchStreamSupplier() throws Exception {
		// 事前条件
		truncateTable("PRODUCT");

		// 処理実行
		var input = getDataFromFile(Paths.get("src/test/resources/data/expected/SqlAgent",
				"testExecuteBatchStream.ltsv"));
		var count = agent.batch(() -> "example/insert_product").paramStream(input.stream()).count();

		assertEquals(100, count, "データの登録件数が不正です。");

		// 検証処理
		var expectedDataList = getDataFromFile(Paths.get(
				"src/test/resources/data/expected/SqlAgent", "testExecuteBatchStream.ltsv"));
		List<Map<String, Object>> actualDataList = agent.query("example/select_product")
				.stream(new MapResultSetConverter(agent.getSqlConfig(), CaseFormat.LOWER_SNAKE_CASE))
				.collect(Collectors.toList());

		assertEquals(expectedDataList.toString(), actualDataList.toString());
	}

	/**
	 * バッチ処理のテストケース(Bean Stream)。
	 */
	@Test
	void testExecuteBatchBeanStream() {
		// 事前条件
		truncateTable("PRODUCT");

		// Entity生成のために一旦登録してSelect
		var data = getDataFromFile(Paths.get("src/test/resources/data/expected/SqlAgent",
				"testExecuteBatchStream.ltsv"));
		agent.batch("example/insert_product").paramStream(data.stream()).count();
		// 取得
		var input = agent.query(Product.class)
				.collect();
		// 再度削除
		truncateTable("PRODUCT");

		// 処理実


，耀眼的闪电照亮整个场景。超级英雄摆出英勇姿态，周围是旋转的乐高碎片和飞舞的积木块，场景中散落着小型乐高小人仔，它们正惊叹地注视着这一切。整体采用电影海报式构图，配以逼真渲染效果，营造出史诗般的超级英雄氛围，色彩浓郁饱和，运用专业的景深和富有戏剧性的光影效果，尺寸为1080x1080的正方形格式。
```

<a id="prompt-269"></a>
## 案例 269：透明X光扫描面板后面 (来源 [@TheRelianceAI](https://x.com/TheRelianceAI/status/1953431382836859074))

<div style="display: flex; justify-content: space-between;">
<img src="./images/269.png" style="width: 48%;" alt="Awesome GPT4o/G极T-4o Image Prompts-透明X光扫描面板后面">
<img src="./images/269-2.jpeg" style="width: 48%;" alt="Awesome GPT4o/GPT-4o Image Prompts-透明X光扫描面板后面">
</div>

**提示词：**
```
Two anime-style characters standing behind a futuristic transparent X-ray scanning panel, each leaning on it casually. Their full bodies are visible through the glowing glass as stylized, semi-transparent X-ray scans. [INSERT SCAN DETAILS HERE — e.g. hybrid anatomy, supernatural markings, implants, etc.]. Futuristic sci-fi interface overlays on the glass, with holographic HUD elements and glowing digital text. The background is minimal and sterile, resembling a high-tech medical chamber. The characters are [INSERT CHARACTER NAMES & DESCRIPTION HERE — appearance, expression, outfit], drawn in modern high-quality anime style. The scene uses soft colored lighting (e.g. cyan, pink, red depending on the pair), expressive animation, and cinematic composition.
```

**中文提示词：**
```
两个动漫风格的角色站在一个未来感的透明X光扫描面板后面，各自随意地靠在面板上。透过发光的玻璃，可以看到他们的全身呈现出风格化的半透明X光扫描效果。【在此插入扫描细节——例如混合解剖结构、超自然标记、植入物等】。玻璃上叠加着未来科幻界面，还有全息平视显示元素和发光的数字文本。背景简洁而无菌，类似一个高科技医疗舱。角色是【在此插入角色姓名和描述——外貌、表情、服装】，采用现代高品质动漫风格绘制。场景使用柔和的彩色灯光（例如根据角色组合使用青色、粉色、红色等），富有表现力的动态效果和电影化的构图。
```

## 案例 268：童趣插画 (来源 [@gnrlyxyz](https://x.com/gnrlyxyz/status/1953477354161848322))

<img src="./images/268.jpeg" style="width: 48%;" alt="Awesome GPT4o/GPT-4o Image


int idx = 0;
                    for(Run run:runs) {
                        DataSet<DataRow> set = selectMetadata(runtime, random, run);
                        map = procedures(runtime, idx++, true, map, query, set);
                    }
                }
            }catch (Exception e) {
                if(ConfigTable.IS_PRINT_EXCEPTION_STACK_TRACE) {
                    e.printStackTrace();
                }else if (ConfigTable.IS_LOG_SQL && log.isWarnEnabled()) {
                    log.warn("{}[procedures][{}][msg:{}]", random, LogUtil.format("根据系统表查询失败", 33), e.toString());
                }
            }
            if (ConfigTable.IS_LOG_SQL_TIME && log.isInfoEnabled()) {
                log.info("{}[procedures][result:{}][执行耗时:{}]", random, map.size(), DateUtil.format(System.currentTimeMillis() - fr));
            }
        }catch (Exception e) {
            if(ConfigTable.IS_PRINT_EXCEPTION_STACK_TRACE) {
                e.printStackTrace();
            }else{
                log.error("[procedures][result:fail][msg:{}]", e.toString());
            }
        }
        return map;
	}

	/**
	 * procedure[命令合成]

	 * 查询表上的 Trigger
	 * @param runtime 运行环境主要包含驱动适配器 数据源或客户端
     * @param query 查询条件 根据metadata属性
	 * @return runs
	 */
	public List<Run> buildQueryProceduresRun(DataRuntime runtime, boolean greedy, Procedure query) {
		if(log.isDebugEnabled()) {
			log.debug(LogUtil.format("子类(" + this.getClass().getSimpleName() + ")未实现 List<Run> buildQueryProceduresRun(DataRuntime runtime, boolean greedy, Procedure query)", 37));
		}
		return new ArrayList<>();
	}

    /**
     * procedure[命令合成]

     * 查询存储参数
     * @param runtime 运行环境主要包含驱动适配器 数据源或客户端
     * @param procedure 存储过程
     * @return List
     */
    @Override
    public List<Run> buildQueryParametersRun(DataRuntime runtime, Procedure procedure) throws Exception {
        List<Run> runs = new ArrayList<>();
        if(log.isDebugEnabled()) {
            log.debug(LogUtil.format("子类(" + this.getClass().getSimpleName() + ")未实现 List<Run> buildQueryParametersRun(DataRuntime runtime, Procedure procedure)", 37));
        }
        return runs;
    }

    /**
     * procedure[结果集封装]

     * Procedure 属性与结果集对应关系
     * @return MetadataFieldRefer
     */
    @Override
    public MetadataFieldRefer initProcedureFieldRefer() {
        return new MetadataFieldRefer(Procedure.class);
    }

    /**
     * procedure[结果集封装]

     * Procedure 属性与结果集对应关系
     * @return MetadataFieldRefer
     */
    @Override
    public MetadataFieldRefer initProcedureParameterFieldRefer() {
        return new MetadataFieldRefer(Parameter.class);
    }
	/**
	 * procedure[结果集封装]

	 * 根据查询结果集构造 Trigger
	 * @param runtime 运行环境主要包含驱动适配器 数据源或客户端
	 * @param index 第几条查询SQL 对照 buildQueryConstraintsRun


_STURGEON`] =  { "Fish Lake Sturgeon",  -855052577,  "inventory_items",  },
	[`PROVISION_FISH_LAKE_STURGEON_LEGENDARY`] =  { "Fish Lake Sturgeon Legendary",  -855052577,  "inventory_items",  },
	[`PROVISION_FISH_LARGEMOUTH_BASS_POOR`] =  { "Poor Fish Largemouth Bass",  -5376850,  "inventory_items",  },
	[`PROVISION_FISH_LARGEMOUTH_BASS`] =  { "Fish Largemouth Bass",  -5376850,  "inventory_items",  },
	[`PROVISION_FISH_LARGEMOUTH_BASS_LEGENDARY`] =  { "Fish Largemouth Bass Legendary",  -5376850,  "inventory_items",  },
	[`PROVISION_FISH_LONGNOSE_GAR_POOR`] =  { "Poor Fish Longnose Gar",  1338219162,  "inventory_items",  },
	[`PROVISION_FISH_LONGNOSE_GAR`] =  { "Fish Longnose Gar",  1338219162,  "inventory_items",  },
	[`PROVISION_FISH_LONGNOSE_GAR_LEGENDARY`] =  { "Fish Longnose Gar Legendary",  1338219162,  "inventory_items",  },
	[`PROVISION_FISH_MUSKIE_POOR`] =  { "Poor Fish Muskie",  -1538397860,  "inventory_items",  },
	[`PROVISION_FISH_MUSKIE`] =  { "Fish Muskie",  -1538397860,  "inventory_items",  },
	[`PROVISION_FISH_MUSKIE_LEGENDARY`] =  { "Fish Muskie Legendary",  -1538397860,  "inventory_items",  },
	[`PROVISION_FISH_NORTHERN_PIKE_POOR`] =  { "Poor Fish Northern Pike",  193037129,  "inventory_items",  },
	[`PROVISION_FISH_NORTHERN_PIKE`] =  { "Fish Northern Pike",  193037129,  "inventory_items",  },
	[`PROVISION_FISH_NORTHERN_PIKE_LEGENDARY`] =  { "Fish Northern Pike Legendary",  193037129,  "inventory_items",  },
	[`PROVISION_FISH_PERCH_POOR`] =  { "Poor Fish Perch",  1416872916,  "inventory_items",  },
	[`PROVISION_FISH_PERCH`] =  { "Fish Perch",  1416872916,  "inventory_items",  },
	[`PROVISION_FISH_PERCH_LEGENDARY`] =  { "Fish Perch Legendary",  1416872916,  "inventory_items",  },
	[


f) => !f.isStatic);
  }

  /// Initialize fields. They follow the sequence:
  ///
  ///   1. field declaration initializer if non-const,
  ///   2. field initializing parameters,
  ///   3. constructor field initializers,
  ///   4. initialize fields not covered in 1-3
  js_ast.Statement _initializeFields(List<Field> fields, [Constructor? ctor]) {
    // Run field initializers if they can have side-effects.
    var ctorFields = ctor?.initializers
        .whereType<FieldInitializer>()
        .map((c) => c.field)
        .toSet();

    var body = <js_ast.Statement>[];
    void emitFieldInit(Field f, Expression? initializer, TreeNode hoverInfo) {
      var virtualField = _classProperties!.virtualFields[f];

      // Avoid calling getSymbol on _declareMemberName since _declareMemberName
      // calls _emitMemberName downstream, which already invokes getSymbol.
      var access = virtualField == null
          ? _declareMemberName(f)
          : getSymbol(virtualField);
      var jsInit = _visitInitializer(initializer, f.annotations);
      body.add(jsInit
          .toAssignExpression(js.call('this.#', [access])
            ..sourceInformation = _nodeStart(hoverInfo))
          .toStatement());
    }

    for (var f in fields) {
      if (f.isStatic) continue;
      var init = f.initializer;
      if (ctorFields != null &&
          ctorFields.contains(f) &&
          (init == null || _constants.isConstant(init))) {
        continue;
      }
      _staticTypeContext.enterMember(f);
      emitFieldInit(f, init, f);
      _staticTypeContext.leaveMember(f);
    }

    // Run constructor field initializers such as `: foo = bar.baz`
    if (ctor != null) {
      for (var init in ctor.initializers) {
        if (init is FieldInitializer) {
          emitFieldInit(init.field, init.value, init);
        } else if (init is LocalInitializer) {
          body.add(visitVariableDeclaration(init.variable));
        } else if (init is AssertInitializer) {
          body.add(visitAssertStatement(init.statement));
        }
      }
    }

    return js_ast.Statement.from(body);
  }

  js_ast.Expression _visitInitializer(
      Expression? init, List<Expression> annotations) {
    // explicitly initialize to null, to avoid getting `undefined`.
    // TODO(jmesserly): do this only for vars that aren't definitely assigned.
    if (init == null) return js_ast.LiteralNull();
    return _annotatedNullCheck(annotations)
        ? notNull(init)
        : _visitExpression(init);
  }

  js_ast.Expression notNull(Expression expr) {
    var jsExpr = _visitExpression(expr);
    if (!isNullable(expr)) return jsExpr;
    return runtimeCall('notNull(#)', [jsExpr]);
  }

  /// If the class has only factory constructors, and it can be mixed in,
  /// then we need to emit a special hidden default constructor for use by
  /// mixins.
  bool _usesMixinNew(Class mixin) {
    // TODO(jmesserly): mixin declarations don't get implicit constructor nodes,
    // even if they have fields, so we need to ensure they're getting generated.
    return mixin.isMixinDeclaration && _hasUnnamedConstructor(mixin) ||
        mixin.superclass?.superclass == null &&
            mixin.constructors.every((c) => c.isExternal);
  }

  js_ast.Statement _addConstructorToClass(Class c, js_ast.Expression className,
      js_ast.LiteralString name, js_ast.Expression jsCtor) {
    jsCtor = defineValueOnClass(c, className, name, jsCtor);
    return js.statement('#.prototype = #.protot


New Guinea", "Paraguay", "Peru", "Philippines", "Poland", "Portugal", "Qatar", "Romania", "Russia", "Saint Lucia", "San Marino", "Saudi Arabia", "Senegal", "Serbia", "Seychelles", "Singapore", "Slovakia", "Slovenia", "South Africa", "South Korea", "Spain", "Sweden", "Switzerland", "Taiwan", "Tanzania", "Thailand", "Trinidad and Tobago", "Tunisia", "Turkey", "Turks and Caicos Islands", "Uganda", "Ukraine", "United Arab Emirates", "United Kingdom", "United States", "Uruguay", "Vatican City", "Venezuela", "Yemen", "Zambia", "Zimbabwe",
        )
        private val PREF_REGION_VALUES = arrayOf(
            "AL", "DZ", "AD", "AO", "AG", "AR", "AU", "AT", "AZ", "BS", "BH", "BB", "BY", "BE", "BZ", "BM", "BO", "BA", "BR", "BG", "BF", "CM", "CA", "CV", "TD", "CL", "CO", "CR", "HR", "CU", "CY", "CZ", "CD", "DK", "DO", "EC", "EG", "SV", "GQ", "EE", "FJ", "FI", "FR", "GF", "PF", "DE", "GH", "GI", "GR", "GT", "GG", "GY", "HN", "HK", "HU", "IS", "IN", "ID", "IQ", "IE", "IL", "IT", "CI", "JM", "JP", "JO", "KE", "XK", "KW", "LV", "LB", "LY", "LI", "LT", "LU", "MK", "MG", "MW", "MY", "ML", "MT", "MU", "MX", "MD", "MC", "ME", "MA", "MZ", "NL", "NZ", "NI", "NE", "NG", "NO", "OM", "PK", "PS", "PA", "PG", "PY", "PE", "PH", "PL", "PT", "QA", "RO", "RU", "LC", "SM", "SA", "SN", "RS", "SC", "SG", "SK", "SI", "ZA", "KR", "ES", "SE", "CH", "TW", "TZ", "TH", "TT", "TN", "TR", "TC", "UG", "UA", "AE", "UK", "US", "UY", "VA", "VE", "YE", "ZM", "ZW",
        )
        private const val PREF_REGION_DEFAULT = "US"

        // JustWatch language in Poster, Titles
        private const val PREF_JW_LANG_KEY = "jw_lang"
        private val PREF_JW_LANG_ENTRIES = arrayOf(
            "Arabic", "Azerbaijani", "Belarusian", "Bulgarian", "Bosnian", "Catalan", "Czech", "German", "Greek", "English", "English (U.S.A.)", "Spanish", "Spanish (Spain)", "Spanish (Latinamerican)", "Estonian", "Finnish", "French", "French (Canada)", "Hebrew", "Croatian", "Hungarian", "Icelandic", "Italian", "Japanese", "Korean", "Lithuanian", "Latvian", "Macedonian", "Maltese", "Polish", "Portuguese", "Portuguese (Portugal)", "Portuguese (Brazil)", "Romanian", "Russian", "Slovakian", "Slovenian", "Albanian", "Serbian", "Swedish", "Swahili", "Turkish", "Ukrainian", "Urdu", "Chinese",
        )
        private val PREF_JW_LANG_VALUES = arrayOf(
            "ar", "az", "be", "bg", "bs", "ca", "cs", "de", "el", "en", "en-US", "es", "es-ES", "es-LA", "et", "fi", "fr", "fr-CA", "he", "hr", "hu", "is", "it", "ja", "ko", "lt", "lv", "mk", "mt", "pl", "pt", "pt-PT", "pt-BR", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "tr", "uk", "ur", "zh",

        )
        private const val PREF_JW_LANG_DEFAULT = "en"


tabase
import androidx.room.migration.Migration

object Migration5 : Migration(4, 5) {
    override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL("DROP TABLE IF EXISTS ARROW")
        database.execSQL(
            "CREATE TABLE IF NOT EXISTS ARROW (" +
                    "_id INTEGER PRIMARY KEY AUTOINCREMENT," +
                    "name TEXT," +
                    "length TEXT," +
                    "material TEXT," +
                    "spine TEXT," +
                    "weight TEXT," +
                    "tip_wight TEXT," +
                    "vanes TEXT," +
                    "nock TEXT," +
                    "comment TEXT," +
                    "thumbnail BLOB," +
                    "image TEXT)"
        )
        database.execSQL("ALTER TABLE ROUND ADD COLUMN arrow INTEGER REFERENCES ARROW ON DELETE SET NULL")
        database.execSQL("ALTER TABLE ROUND ADD COLUMN comment TEXT DEFAULT ''")
        database.execSQL("ALTER TABLE SHOOT ADD COLUMN comment TEXT DEFAULT ''")
        database.execSQL("UPDATE ROUND SET target=0 WHERE target=1 OR target=2 OR target=3")
        database.execSQL("UPDATE ROUND SET target=2 WHERE target=5 OR target=6 OR target=7")
        database.execSQL("UPDATE ROUND SET target=3 WHERE target=4")
        database.execSQL("UPDATE ROUND SET target=4 WHERE target=8")
        database.execSQL("UPDATE ROUND SET target=5 WHERE target=9")
        database.execSQL("UPDATE ROUND SET target=6 WHERE target=10")
        database.execSQL(
            "UPDATE SHOOT SET points=2 WHERE _id IN (SELECT s._id " +
                    "FROM ROUND r, PASSE p, SHOOT s LEFT JOIN BOW b ON b._id=r.bow " +
                    "WHERE r._id=p.round AND s.passe=p._id " +
                    "AND (r.bow=-2 OR b.type=1) AND s.points=1 AND r.target=3)"
        )
    }
}
/*
 * Copyright (C) 2018 Florian Dreier
 *
 * This file is part of MyTargets.
 *
 * MyTargets is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * MyTargets is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

package de.dreier.mytargets.base.db.dao

import androidx.lifecycle.LiveData
import androidx.room.*
import de.dreier.mytargets.shared.models.db.Round
import de.dreier.mytargets.shared.models.db.Training

@Dao
abstract class TrainingDAO {
    @Query("SELECT * FROM `Training`")
    abstract fun loadTrainings(): List<Training>

    @Query("SELECT * FROM `Training`")
    abstract fun loadTrainingsLive(): LiveData<List<Training>>

    @Query("SELECT * FROM `Training` WHERE `id` = :id")
    abstract fun loadTraining(id: Long): Training

    @Query("SELECT * FROM `Training` WHERE `id` = :id")
    abstract fun loadTrainingLive(id: Long): LiveData<Training>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    abstract fun insertTraining(training: Training): Long

    @Update
    abstract fun updateTraining(training: Training)

    @Query("UPDATE `Training` SET `comment`=:comment WHERE `id` = :trainingId")
    abstract fun updateComment(trainingId: Long, comment: String)

    @Transaction
    open fun insertTraining(training: Training, rounds: List<Round>) {
        training.id = insertTraining(training)
        for (round in rounds) {
            round.trainingId = training.id
            round.id = insertRound(round)
        }
    }

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    abstract fun insertRound(round: Round): Long


<Object + 'static>
{
	fn from(shape:ModelShape) -> Self
	{
		Rc::new(shape)
	}
}

impl From<ModelShape> for Arc<Object + 'static>
{
	fn from(shape:ModelShape) -> Self
	{
		Arc::new(shape)
	}
}

impl From<ModelShape> for Rc<RefCell<Object + 'static>>
{
	fn from(shape:ModelShape) -> Self
	{
		Rc::new(RefCell::new(shape))
	}
}

impl From<ModelShape> for Arc<RefCell<Object + 'static>>
{
	fn from(shape:ModelShape) -> Self
	{
		Arc::new(RefCell::new(shape))
	}
}

pub struct ModelShapeBuilder
{
	pub position:float3,
	pub scale:float3,
	pub rotation:float3,
	pub shapes:Vec<MeshShape>
}

impl ModelShapeBuilder
{
	#[inline]
	pub fn new() -> Self
	{
		Self
		{
			position:float3::zero(),
			scale:float3::one(),
			rotation:float3::zero(),
			shapes:Vec::new(),
		}
	}

	#[inline]
	pub fn build(self) -> ModelShape
	{
		let mut mesh = ModelShape::new(self.shapes);
		mesh.set_translate(self.position);
		mesh.set_scale(self.scale);
		mesh.set_rotation(self.rotation);
		mesh
	}

	#[inline]
	pub fn add_shape(mut self, shape:MeshShape) -> Self
	{
		self.shapes.push(shape);
		self
	}

	#[inline]
	pub fn set_translate(mut self, pos:float3) -> Self
	{
		self.position = pos;
		self
	}

	#[inline]
	pub fn set_scale(mut self, sz:float3) -> Self
	{
		self.scale = sz;
		self
	}

	#[inline]
	pub fn set_rotation(mut self, rot:float3) -> Self
	{
		self.rotation = rot;
		self
	}
}pub mod schemas;
pub mod models;

mod theinfinitytimes_lib {
    pub trait PreSave {
        fn pre_save(&self) {
            panic!("Abstract method");
        }
    }
    pub trait PreSaveMut{
        fn pre_save(&mut self){ panic!("Abstract method")}
    }
}
extern crate trim_in_place;

use trim_in_place::TrimInPlace;

#[test]
fn trim() {
    let mut s = String::from(" 1234 abcd  ");

    s.trim_in_place();

    assert_eq!("1234 abcd", s);
}

#[test]
fn trim_start() {
    let mut s = String::from(" 1234 abcd  ");

    s.trim_start_in_place();

    assert_eq!("1234 abcd  ", s);
}

#[test]
fn trim_end() {
    let mut s = String::from(" 1234 abcd  ");

    s.trim_end_in_place();

    assert_eq!(" 1234 abcd", s);
}

#[test]
fn trim_matches() {
    let mut s = String::from("X1234 abcdXX");

    s.trim_matches_in_place('X');

    assert_eq!("1234 abcd", s);
}

#[test]
fn trim_start_matches() {
    let mut s = String::from("X1234 abcdXX");

    s.trim_start_matches_in_place('X');

    assert_eq!("1234 abcdXX", s);
}

#[test]
fn trim_end_matches() {
    let mut s = String::from("X1234 abcdXX");

    s.trim_end_matches_in_place('X');

    assert_eq!("X1234 abcd", s);
}
use sokol_bindings::{
    cstr,
    sg::{self, Backend, DepthState, LayoutDesc, S


 = await this.userDao.getUserInfo(Number(id))
      let userJson
      if(userInfo) {
        userJson = userInfo.toJSON()
        await this.userDao.deleteUser(userJson)
        return '删除成功'
      }else {
        return '用户不存在'
      }
    }catch (e) {
      return '删除失败'
    }
  }
}

export default UserService
var fullScore1:number;
var fullScore2:number;
var max:number=0;
var manOfTheMatch:string="";

class value {
    constructor() {
            var sum:number;
            var totalScore:number=0;
            var table1 = document.getElementById("teamOne");
            var tableBody = document.getElementById("bodyOne");
            table1.appendChild(tableBody);
            for(var j=1;j<=10;j++)
            {
                sum=0;
                var tableR = document.createElement("tr");
                var tableH = document.createElement("th");
                tableH.innerText = "Person "+j;
                tableBody.appendChild(tableR);
                tableR.appendChild(tableH);
                for(var i=1;i<7;i++)
                {
                    var tableC = document.createElement("td");
                    var data = Math.floor((Math.random() * 10) + 1);
                    sum += data;
                    totalScore += data;
                    tableC.innerHTML = ""+data;
                    tableR.appendChild(tableC);
                }
                if(sum>max)
                {
                    max=sum;
                    manOfTheMatch = "Person "+j;
                }
                var totalSum =  document.createElement("td");
                totalSum.innerHTML = ""+sum;
                tableR.appendChild(totalSum);
            }
            fullScore1 = totalScore;
            var showScore = document.getElementById("team1Score");
            showScore.innerHTML = ""+totalScore;
        }
}

class value2 {
    constructor() {
        var sum:number;
        var totalScore:number=0;
        var count=11;
        var table1 = document.getElementById("teamTwo");
        var tableBody = document.getElementById("bodyTwo");
        table1.appendChild(tableBody);
        for(var j=1;j<=10;j++)
        {
            sum=0;
            var tableR = document.createElement("tr");
            var tableH = document.createElement("th");
            tableH.innerText = "Person "+count;
            count++;
            tableBody.appendChild(tableR);
            tableR.appendChild(tableH);
            for(var i=1;i<=6;i++)
            {
                var tableC = document.createElement("td");
                var data = Math.floor((Math.random() * 10) + 1);
                sum += data;
                totalScore += data;
                tableC.innerHTML = ""+data;
                tableR.appendChild(tableC);
            }
            if(sum>max)
            {
                max=sum;
                var c = count;
                c = c-1;
                manOfTheMatch = "Person "+c;
            }
            var totalSum =  document.createElement("td");
            totalSum.innerHTML = ""+sum;
            tableR.appendChild(totalSum);
        }
        fullScore2 = totalScore;
        var showScore = document.getElementById("team2Score");
        showScore.innerHTML = ""+totalScore;
    }
}

function show(){
    new value();
}

var buttonOne =


dits: monaco.languages.IWorkspaceTextEdit[] = [];
		for (const fix of fixes.filter(fix => fix.autoFixAvailable)) {
			if (fix.severity === monaco.MarkerSeverity.Hint)
				continue; // do not auto-fix "hint" level diagnostics in the global auto-fix
			if (edits.some(x => monaco.Range.areIntersecting(x.textEdit.range, fix.textEdit.range)))
				continue; // overlapping edits are not allowed
			edits.push({
				textEdit: fix.textEdit,
				resource: model.uri,
				versionId: undefined,
			});
		}

		if (edits.length === 0)
			return [];

		return [
			{
				title: "Fix all auto-fixable problems",
				kind: "quickfix",
				edit: { edits }
			},
			{
				title: "Fix all ESLint auto-fixable problems",
				kind: "source.fixAll.eslint",
				edit: { edits }
			}
		];
	}

	/**
	 * Creates a new config where all "info" and "hint" level severities are replaced by "warn".
	 */
	private createEsLintCompatibleConfig(): EsLintConfig {
		const compatConfig = (JSON.parse(JSON.stringify(this.config)) ?? {}) as EsLintConfig;
		for (const ruleId in compatConfig.rules) {
			const rule = compatConfig.rules[ruleId];
			if (rule === undefined)
				continue;
			if (Array.isArray(rule) && ((rule[0] as ExtendedRuleLevel) === "info" || (rule[0] as ExtendedRuleLevel) === "hint"))
				rule[0] = "warn";
			if ((rule as ExtendedRuleLevel) === "info" || (rule as ExtendedRuleLevel) === "hint")
				compatConfig.rules[ruleId] = "warn";
		}
		return compatConfig;
	}

	/**
	 * Checks if a normally "warn" level diagnostic is really an "info" or "hint" level diagnostic.
	 */
	private isInfoOrHint(diagnostic: Linter.LintMessage, severity: "info" | "hint"): boolean {
		if (diagnostic.severity !== 1 || diagnostic.ruleId === null)
			return false;
		const rule = this.config?.rules?.[diagnostic.ruleId];
		if (rule === undefined)
			return false;
		if (Array.isArray(rule))
			return (rule[0] as ExtendedRuleLevel) === severity;
		return (rule as ExtendedRuleLevel) === severity;
	}

	private getRuleId(marker: monaco.editor.IMarkerData): string | undefined {
		if (marker.source !== this.owner)
			return undefined;
		return typeof marker.code === "string" ? marker.code : marker.code?.value;
	}

	private toMarkerData(diagnostic: Linter.LintMessage): monaco.editor.IMarkerData {
		return {
			message: diagnostic.message,
			...this.toRange(diagnostic),
			source: this.owner,
			severity: this.toSeverity(diagnostic),
			code: this.toCode(diagnostic),
			tags: diagnostic.ruleId === "no-unused-vars" ? [monaco.MarkerTag.Unnecessary] : []
		};
	}

	private toRange(diagnostic: Linter.LintMessage): monaco.IRange {
		return {
			startLineNumber: diagnostic.line,
			startColumn: diagnostic.column,
			endLineNumber: diagnostic.endLine ?? diagnostic.line,
			endColumn: diagnostic.endColumn ?? diagnostic.column,
		};
	}

	private toSeverity(diagnostic: Linter.LintMessage): monaco.MarkerSeverity {
		if (diagnostic.severity === 2)
			return monaco.MarkerSeverity.Error;
		if (diagnostic.severity === 1 && this.isInfoOrHint(diagnostic, "info"))
			return monaco.Marker


_("Learn more about this course")}

    % if is_enrolled_in_course:

          ${_("Go to course")}

    % else:

          ${_("Enroll in this course")}

    % endif

</%block>
<%page expression_filter="h"/>
<%namespace name='static' file='static_content.html'/>
<%! from django.utils.translation import gettext as _ %>

    % if settings.FEATURES.get('COURSES_ARE_BROWSABLE'):

          ## limiting the course number by using HOMEPAGE_COURSE_MAX as the maximum number of courses
          %for course in courses[:homepage_course_max]:

              <%include file="course.html" args="course=course" />

        %endfor

    ## in case there are courses that are not shown on the homepage, a 'View all Courses' link should appear
      % if homepage_course_max and len(courses) > homepage_course_max:

         ${_("View all Courses")}

    % endif
    % endif

<%page expression_filter="h"/>
<%! from django.utils.translation import gettext as _ %>

<%inherit file="main.html" />
<%namespace name='static' file='static_content.html'/>

<%block name="headextra">

</%block>

${_("Log In")}

    <form id="login_form" class="login_form" method="post" action="/openid/provider/login/">
%if error:

${_("Email or password is incorrect.")}

%endif

${_("Your username, email, and full name will be sent to {destination}, where the collection and use of this information will be governed by their terms of service and privacy policy.").format(destination=return_to)}

      ${_("E-mail")}
      <input type="text" name="email" placeholder="${_('E-mail')}" autofocus="autofocus" />
      ${_("Password")}
      <input type="password" name="password" placeholder="${_('Password')}" />

        <input name="submit" type="submit" value="${_('Return To %s') % return_to}" />

    </form>

<%page expression_filter="h"/>
<%!
from django.utils.translation import get


-@field rename _.lspconfig.settings.intelephense.Rename
-- Path to a Node.js executable. Use this if you wish to use a different version of Node.js. Defaults to Node.js shipped with VSCode.
---@field runtime string
-- Configure stub files for built in symbols and common extensions. The default setting includes PHP core and all bundled extensions.
--
-- ```lua
-- default = { "apache", "bcmath", "bz2", "calendar", "com_dotnet", "Core", "ctype", "curl", "date", "dba", "dom", "enchant", "exif", "FFI", "fileinfo", "filter", "fpm", "ftp", "gd", "gettext", "gmp", "hash", "iconv", "imap", "intl", "json", "ldap", "libxml", "mbstring", "meta", "mysqli", "oci8", "odbc", "openssl", "pcntl", "pcre", "PDO", "pgsql", "Phar", "posix", "pspell", "random", "readline", "Reflection", "session", "shmop", "SimpleXML", "snmp", "soap", "sockets", "sodium", "SPL", "sqlite3", "standard", "superglobals", "sysvmsg", "sysvsem", "sysvshm", "tidy", "tokenizer", "xml", "xmlreader", "xmlrpc", "xmlwriter", "xsl", "Zend OPcache", "zip", "zlib" }
-- ```
---@field stubs string[]
---@field telemetry _.lspconfig.settings.intelephense.Telemetry
---@field trace _.lspconfig.settings.intelephense.Trace

---@class lspconfig.settings.intelephense
---@field intelephense _.lspconfig.settings.intelephense.Intelephense

---@class _.lspconfig.settings.java_language_server.Trace
-- Traces the communication between VSCode and the language server.
--
-- ```lua
-- default = "off"
-- ```
---@field server "off" | "messages" | "verbose"

---@class _.lspconfig.settings.java_language_server.Java
-- List of modules to allow access to, for example ["jdk.compiler/com.sun.tools.javac.api"]
---@field addExports string[]
-- Relative paths from workspace root to .jar files, .zip files, or folders that should be included in the Java class path
---@field classPath string[]
-- Command to debug one test method, for example ["mvn", "test", "-Dmaven.surefire.debug", "-Dtest=${class}#${method}". The test should start paused, listening for the debugger on port 5005.
---@field debugTestMethod string[]
-- Relative paths from workspace root to .jar files or .zip files containing source code, or to folders that should be included in the Java doc path
---@field docPath string[]
-- External dependencies of the form groupId:artifactId:version or groupId:artifactId:packaging:version:scope
---@field externalDependencies string[]
-- Absolute path to your Java home directory
---@field home string
-- Command to run all tests in a class, for example ["mvn", "test", "-Dtest=${class}"
---@field testClass string[]
-- Command to run one test method, for example ["mvn", "test", "-Dtest=${class}#${method}"
---@field testMethod string[]
---@field trace _.lspconfig.settings.java_language_server.Trace

---@class lspconfig.settings.java_language_server
---@field java _.lspconfig.settings.java_language_server.Java

---@class _.lspconfig.settings.jdtls.Autobuild
-- Enable/disable the 'auto build'
--
-- ```lua
-- default = true
-- ```
---@field enabled boolean

---@class _.lspconfig.settings.jdtls.Cleanup
-- The list of clean ups to be run on the current document when it's saved or when the cleanup command is issued. Clean ups can automatically fix code style or programming mistakes. Click [HERE](command:_java.learnMoreAboutCleanUps) to learn more about what each clean up does.


r2
	add	$txtseek-[2*25],r2
	mov	r2,tseekp
	mov	(r2),r0
	jsr	r5,oset; txtp
	add	$trelseek-txtseek,r2
	mov	(r2),r0
	mov	r2,rseekp
	jsr	r5,oset; relp
	mov	(sp)+,r0
	mov	savdot-[2*25](r0),dot
	asr	r0
	sub	$25-2,r0
	mov	r0,dot-2	/ new . relocation
	tst	(sp)+
	rts	pc

opl32:
	cmp	r4,$200
	blo	1f
	mov	r4,-(sp)
	jsr	pc,readop
	jsr	pc,readop
	jsr	pc,expres
	mov	(sp)+,r0
	bit	$37,symtab(r0)
	bne	1f
	bis	$40,symtab(r0)
	mov	r2,symtab+2(r0)
1:
	tst	(sp)+
	rts	pc

addres:
	clr	-(sp)
4:
	cmp	r4,$'(
	beq	alp
	cmp	r4,$'-
	beq	amin
	cmp	r4,$'$
	beq	adoll
	cmp	r4,$'*
	bne	getx
	jmp	astar
getx:
	jsr	pc,expres
	cmp	r4,$'(
	bne	2f
	jsr	pc,readop
	mov	r2,(r5)+
	mov	r3,(r5)+
	mov	xsymbol,(r5)+
	jsr	pc,expres
	jsr	pc,checkreg
	jsr	pc,checkrp
	bis	$60,r2
	bis	(sp)+,r2
	rts	pc

2:
	cmp	r3,$24
	bne	1f
	jsr	pc,checkreg
	bis	(sp)+,r2
	rts	pc
1:
	mov	r3,-(sp)
	bic	$40,r3
	mov	(sp)+,r3
	bis	$100000,r3
	sub	dot,r2
	sub	$4,r2
	cmp	r5,$adrbuf
	beq	1f
	sub	$2,r2
1:
	mov	r2,(r5)+		/ index
	mov	r3,(r5)+		/ index


32 = 110;
// pub const USDHC2: u32 = 111;
// pub const USB: u32 = 112;
// pub const USB: u32 = 113;
// pub const ENET: u32 = 114;
// pub const ENET: u32 = 115;
// pub const XBAR1: u32 = 116;
// pub const XBAR1: u32 = 117;
// pub const ADC_ETC: u32 = 118;
// pub const ADC_ETC: u32 = 119;
// pub const ADC_ETC: u32 = 120;
// pub const ADC_ETC: u32 = 121;
// pub const PIT: u32 = 122;
// pub const ACMP: u32 = 123;
// pub const ACMP: u32 = 124;
// pub const ACMP: u32 = 125;
// pub const ACMP: u32 = 126;
// pub const ENC1: u32 = 129;
// pub const ENC2: u32 = 130;
// pub const ENC3: u32 = 131;
// pub const ENC4: u32 = 132;
// pub const QTIMER1: u32 = 133;
// pub const QTIMER2: u32 = 134;
// pub const QTIMER3: u32 = 135;
// pub const QTIMER4: u32 = 136;
// pub const FLEXPWM2: u32 = 137;
// pub const FLEXPWM2: u32 = 138;
// pub const FLEXPWM2: u32 = 139;
// pub const FLEXPWM2: u32 = 140;
// pub const FLEXPWM2: u32 = 141;
// pub const FLEXPWM3: u32 = 142;
// pub const FLEXPWM3: u32 = 143;
// pub const FLEXPWM3: u32 = 144;
// pub const FLEXPWM3: u32 = 145;
// pub const FLEXPWM3: u32 = 146;
// pub const FLEXPWM4: u32 = 147;
// pub const FLEXPWM4: u32 = 148;
// pub const FLEXPWM4: u32 = 149;
// pub const FLEXPWM4: u32 = 150;
// pub const FLEXPWM4: u32 = 151;
#![cfg_attr(not(feature = "std"), no_std)]

use itp_storage::{storage_map_key, StorageHasher};
use itp_types::H256;
use pallet_ajuna_gameregistry::game::GameEngine;
use sp_std::prelude::Vec;

pub const REGISTRY: &str = "GameRegistry";

pub struct RegistryStorage;

// Separate the prefix from the rest because in our case we changed the storage prefix due to
// the rebranding. With the below implementation of the `RegistryStorageKeys`, we could simply
// define another struct `OtherStorage`, implement `StoragePrefix` for it, and get the
// `RegistryStorageKeys` implementation for free.
pub trait StoragePrefix {
	fn prefix() -> &'static str;
}

impl StoragePrefix for RegistryStorage {
	fn prefix() -> &'static str {
		REGISTRY
	}
}

pub trait RegistryStorageKeys {
	fn queue_game() -> Vec<u8>;
	fn game_registry(game: H256) -> Vec<u8>;
}

impl<S: StoragePrefix> RegistryStorageKeys for S {
	fn queue_game() -> Vec<u8> {
		let game_engine = GameEngine::new(1u8, 1u8);
		storage_map_key(Self::prefix(), "GameQueues", &game_engine, &StorageHasher::Identity)
	}

	fn game_registry(game: H256) -> Vec<u8> {
		storage_map_key(Self::prefix(), "GameRegistry", &game, &StorageHasher::Identity)
	}
}
<filename>src/strings/remove


        45.37365538326699,
        13,
    )?;
    test("x / 2 / 3", &[1.0], 1.0 / 6.0, 3)?;
    test("x * 2 / 3", &[1.0], 2.0 / 3.0, 2)?;
    test(
        "(({x}^2.0)*(({x}^1.0)*2.0))+((({x}^1.0)*2.0)*({x}^2.0))",
        &[2.21],
        43.175444,
        10,
    )?;
    test("(((a+x^2*x^2)))", &[3.0, 2.21], 26.854432810000002, 5)?;

    let flatex = FlatEx::<f64>::from_str("1*sin(2-0.1) + x")?;
    match flatex.nodes[0].kind {
        FlatNodeKind::Num(n) => assert_float_eq_f64(n, 1.9f64.sin()),
        _ => unreachable!(),
    }
    match flatex.nodes[1].kind {
        FlatNodeKind::Var(idx) => assert_eq!(idx, 0),
        _ => unreachable!(),
    }

    let flatex = OwnedFlatEx::<f64>::from_str("y + 1 - cos(1/(1*sin(2-0.1))-2) + 2 + x")?;
    assert_eq!(flatex.nodes.len(), 3);
    match flatex.nodes[0].kind {
        FlatNodeKind::Var(idx) => assert_eq!(idx, 1),
        _ => unreachable!(),
    }
    match flatex.nodes[1].kind {
        FlatNodeKind::Num(_) => (),
        _ => unreachable!(),
    }
    match flatex.nodes[2].kind {
        FlatNodeKind::Var(idx) => assert_eq!(idx, 0),
        _ => unreachable!(),
    }
    Ok(())
}

#[test]
fn test_unparse() -> ExResult<()> {
    fn test(text: &str, text_ref: &str) -> ExResult<()> {
        let mut flatex = FlatEx::<f64>::from_str(text)?;
        assert_eq!(flatex.unparse()?, text);
        flatex.reduce_memory();
        assert!(flatex.unparse().is_ok());

        let mut flatex = OwnedFlatEx::<f64>::from_str(text)?;
        assert_eq!(flatex.unparse()?, text);
        flatex.reduce_memory();
        assert!(flatex.unparse().is_ok());

        let deepex = DeepEx::<f64>::from_ops(text, &FloatOpsFactory::make())?;
        assert_eq!(deepex.unparse_raw(), text_ref);
        Ok(())
    }
    let text = "5+x";
    let text_ref = "5.0+{x}";
    test(text, text_ref)?;
    let text = "sin(5+var)^(1/{y})+{var}";
    let text_ref = "sin(5.0+{var})^(1.0/{y})+{var}";
    test(text, text_ref)?;
    let text = "-(5+var)^(1/{y})+{var}";
    let text_ref = "-(5.0+{var})^(1.0/{y})+{var}";
    test(text, text_ref)?;
    let text = "cos(sin(-(5+var)^(1/{y})))+{var}";
    let text_ref = "cos(sin(-(5.0+{var})^(1.0/{y})))+{var}";
    test(text, text_ref)?;
    let text = "cos(sin(-5+var^(1/{y})))-{var}";
    let text_ref = "cos(sin(-5.0+{var}^(1.0/{y})))-{var}";
    test(text, text_ref)?;
    let text = "cos(sin(-z+var*(1/{y})))+{var}";
    let text_ref = "cos(sin(-({z})+{var}*(1.0/{y})))+{var}";
    test(text, text_ref)?;
    Ok(())
}
<gh_stars>0
// This