   val existed = cache[processedContent]
    if (existed == null) {
        cache[processedContent] = SimilarDanmakuItemData(processedContent, item)
    } else if (existed.near(nearMs, maxMs, item.position)) {
        existed.inc(item, result)
    } else {
        existed.complete(result, mergedSize)
        cache[processedContent] = SimilarDanmakuItemData(processedContent, item)
        result.add(item.copyWith(mergedType = DanmakuItemData.MERGED_TYPE_ORIGINAL))
    }
}

class SimilarDanmakuItemData(
    val content: String,
    private val first: DanmakuItemData,
) {
    private var last: DanmakuItemData = first
    private var number: Int = 1

    fun near(nearMs: Long, maxMs: Long, pos: Long): Boolean =
        pos - last.position <= nearMs && pos - first.position <= maxMs

    fun inc(item: DanmakuItemData, result: MutableList<DanmakuItemData>) {
        last = item
        number += 1
        result.add(item.copyWith(mergedType = DanmakuItemData.MERGED_TYPE_ORIGINAL))
    }

    private fun createMerged(mergedSize: Int): DanmakuItemData =
        DanmakuItemData(
            danmakuId = Random.nextLong(),
            position = first.position + 100,
            content = "($number)${first.content}",
            mode = first.mode,
            textSize = mergedSize,
            textColor = first.textColor,
            score = first.score,
            danmakuStyle = DanmakuItemData.DANMAKU_STYLE_NONE,
            mergedType = DanmakuItemData.MERGED_TYPE_MERGED
        )

    fun complete(result: MutableList<DanmakuItemData>, mergedSize: Int) {
        if (number == 1) {
            result.add(first)
        } else {
            result.add(first.copyWith(mergedType = DanmakuItemData.MERGED_TYPE_ORIGINAL))
            result.add(createMerged(mergedSize))
        }
    }
}

fun DanmakuItemData.copyWith(
    danmakuId: Long? = null,
    position: Long? = null,
    content: String? = null,
    mode: Int? = null,
    textSize: Int? = null,
    textColor: Int? = null,
    score: Int? = null,
    danmakuStyle: Int? = null,
    userId: Long? = null,
    mergedType: Int? = null,
): DanmakuItemData =
    DanmakuItemData(
        danmakuId = danmakuId ?: this.danmakuId,
        position = position ?: this.position,
        content = content ?: this.content,
        mode = mode ?: this.mode,
        textSize = textSize ?: this.textSize,
        textColor = textColor ?: this.textColor,
        score = score ?: this.score,
        danmakuStyle = danmakuStyle ?: this.danmakuStyle,
        userId = userId ?: this.userId,
        mergedType = mergedType ?: this.mergedType
    )
private fun processContent(content: String): String {
    if (content.isBlank()) {
        return ""
    }
    return removeEndingChars(normalizeContent(content))
}

private val ENDING_CHARS = ".。,，/?？!！…~～@^、+=-_♂♀".toCharArray()
private fun removeEndingChars(content: String): String {
    if (content.isEmpty()) {
        return content
    }
    if (ENDING_CHARS.contains(content.last())) {
        return removeEndingChars(content.substring(0, content.length - 1).trimEnd())
    }
    return content
}

private val REPLACE_CHAR_MAP = mapOf(
    '　' to ' ',
    '１' to '1',
    '２' to '2',
    '３' to '3',
    '４' to '4',
    '５' to '5',
    '６' to '6',
    '７' to '7',
    '８' to '8',
    '９' to '9',
    '０


    if isIncreasing(arr):
        return arr

    # Otherwise
    else:
        return "-1"

# Driver Code
if __name__ == '__main__':

    arr = [511, 321, 323, 432, 433]
    res = sortArr(arr)

    for i in res:
        print(i, end = " ")
```

## C#

```
// C# program for the above approach
using System;
public class GFG
{

  // Function to check if an array is
  // sorted in increasing order or not
  static bool isIncreasing(int []arr)
  {

    // Traverse the array
    for(int i = 0; i < arr.Length - 1; i++)
    {
      if (arr[i] > arr[i + 1])
        return false;
    }
    return true;
  }

  // Function to sort the array
  // by left shifting digits of
  // array elements
  static int[] sortArr(int []arr)
  {

    // Stores previous array
    // element
    int prev = -1;

    // Traverse the array []arr
    for(int i = 0; i < arr.Length; i++)
    {

      // Stores current element
      int optEle = arr[i];

      // Stores current element
      // in String format
      String strEle = String.Join("",arr[i]);

      // Left-shift digits of current
      // element in all possible ways
      for(int idx = 0; idx < strEle.Length; idx++)
      {

        // Left-shift digits of current
        // element by idx
        String strEle2 = strEle.Substring(idx) +
          strEle.Substring(0, idx);
        int temp = Int32.Parse(strEle2);

        // If temp greater than or equal to
        // prev and temp less than optEle
        if (temp >= prev && temp < optEle)
          optEle = temp;
      }

      // Update arr[i]
      arr[i] = optEle;

      // Update prev
      prev = arr[i];
    }

    // If arr is in increasing order
    if (isIncreasing(arr))
      return arr;

    // Otherwise
    else
    {
      return new int[]{ -1 };
    }
  }

  // Driver Code
  public static void Main(String[] args)
  {
    int []arr = { 511, 321, 323, 432, 433 };
    int []res = sortArr(arr);
    for(int i = 0; i < res.Length; i++)
      Console.Write(res[i]+ " ");
  }
}

// This code is contributed by shikhasingrajput.
```

## java 描述语言

```
<script>
    // Javascript program for the above approach

    // Function to check if an array is
    // sorted in increasing order or not
    function isIncreasing(arr)
    {

        // Traverse the array
        for(let i = 0; i < arr.length - 1; i++)
        {
            if (arr[i] > arr[i + 1])
                return false;
        }
        return true;
    }

    // Fu


,getCategoryName: function(str) {
		switch(str) {
		case "level design":
			str = "level";
			break;
		case "genre":case "subgenre":case "supergenre":
			str = "genre";
			break;
		default:
			str = str;
		}
		return str;
	}
	,getTagNames: function(tags,showDisabled) {
		if(showDisabled == null) {
			showDisabled = false;
		}
		var arr = [];
		var _g = 0;
		while(_g < tags.length) {
			var tagId = tags[_g];
			++_g;
			var pass = true;
			if(!showDisabled && this.disabledTags != null) {
				var _g1 = 0;
				var _g2 = this.disabledTags;
				while(_g1 < _g2.length) {
					var dTag = _g2[_g1];
					++_g1;
					if(dTag == tagId) {
						pass = false;
						break;
					}
				}
			}
			if(pass) {
				var name = this.getTagName(tagId);
				if(name != "") {
					arr.push(name);
				}
			}
		}
		return arr;
	}
	,getTagName: function(id) {
		return Main.tagDB.getName(id);
	}
	,setDetails: function(details) {
		if(details == null) {
			this.clear();
			return;
		}
		this.appid = details.appid;
		this.title = details.title;
		this.header = details.capsule;
		this.screenshot = details.screenshots != null && details.screenshots.length > 0 ? details.screenshots[0] : "";
		this.screenshots = details.screenshots != null ? details.screenshots.slice() : [];
		this.microtrailer_webm = details.microtrailer_webm;
		this.microtrailer_mpeg4 = details.microtrailer_mpeg4;
		this.discountBlock = details.discount_block;
		this.comingSoon = details.coming_soon;
		this.tags = this.copyTags(details.tags);
		this.url = details.url;
		this.shortDescription = details.shortDescription;
	}
	,copyValuesFrom: function(other) {
		this.appid = other.appid;
		this.title = other.title;
		this.header = other.header;
		this.discountBlock = other.discountBlock;
		this.comingSoon = other.comingSoon;
		this.screenshot = other.screenshot;
		this.screenshots = other.screenshots != null ? other.screenshots.slice() : [];
		this.recommender = other.recommender;
		this.microtrailer_webm = other.microtrailer_webm;
		this.microtrailer_mpeg4 = other.microtrailer_mpeg4;
		this.tags = this.copyTags(other.tags);
		this.tagEntries = this.copyTagEntries(other.tagEntries);
		this.tagCategories = this.copyTagCategories(other.tagCategories);
		this.disabledTags = other.disabledTags != null ? other.disabledTags.slice() : [];
		this.boostedTags = other.boostedTags != null ? other.boostedTags.slice() : [];
		this.url = other.url;
		this.shortDescription = other.shortDescription;
	}
	,copyTagCategories: function(otherCategories) {
		var arr = [];
		var _g = 0;
		while(_g < otherCategories.length) {
			var t = otherCategories[_g];
			++_g;
			arr.push({ category : t.category, score : t.score, tags : t.tags.slice()});
		}
		return arr;
	}
	,co


C272.1 245.2 272 245.3 272 245.5v266.5c60.04-40.39 164.7-50.76 213.5-53.28C500.4 457.9 512 445.9 512 431.7V219.2C512 203.6 498.4 191.1 482.2 192zM352 96c0-53-43-96-96-96S160 43 160 96s43 96 96 96S352 149 352 96z"})),rawMode:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 100 60"},React__namespace.createElement("path",{stroke:"var(--icon-fill-color)",strokeWidth:"4",d:"M20 10H10m10 0H10m0 0v40m0-40v40m0 0h10m-10 0h10M40 10H30m10 0H30m0 0v40m0-40v40m0 0h10m-10 0h10M60 10h10m-10 0h10m0 0v40m0-40v40m0 0H60m10 0H60M80 10h10m-10 0h10m0 0v40m0-40v40m0 0H80m10 0H80"})),parsedMode:React__namespace.createElement("svg",{"aria-hidden":"true",focusable:"false",role:"img",xmlns:"http://www.w3.org/2000/svg",viewBox:"0 0 576 512",stroke:"var(--icon-fill-color)",strokeWidth:"20"},React__namespace.createElement("path",{d:"M574.1 280.4l-45.38-181.8c-5.875-23.63-21.62-44-43-55.75c-21.5-11.75-46.1-14.13-70.25-6.375l-15.25 5.125c-8.375 2.75-12.87 11.88-10 20.25l5 15.13c2.75 8.375 11.88 12.88 20.25 10.13l13.12-4.375c10.88-3.625 23-3.625 33.25 1.75c10.25 5.375 17.5 14.5 20.38 25.75l38.38 153.9c-22.12-6.875-49.75-12.5-81.13-12.5c-34.88 0-73.1 7-114.9 26.75H251.4C210.5 258.6 171.4 251.6 136.5 251.6c-31.38 0-59 5.625-81.12 12.5l38.38-153.9c2.875-11.25 10.12-20.38 20.5-25.75C124.4 79.12 136.5 79.12 147.4 82.74l13.12 4.375c8.375 2.75 17.5-1.75 20.25-10.13l5-15.13C188.6 53.49 184.1 44.37 175.6 41.62l-15.25-5.125c-23.13-7.75-48.75-5.375-70.13 6.375c-21.37 11.75-37.12 32.13-43 55.75L1.875 280.4C.6251 285.4 .0001 290.6 .0001 295.9v70.25C.0001 428.1 51.63 480 115.3 480h37.13c60.25 0 110.4-46 114.9-105.4l2.875-38.63h35.75l2.875 38.63C313.3 433.1 363.4 480 423.6 480h37.13c63.62 0 115.2-51 115.2-113.9V295.9C576 290.6 575.4 285.5 5


.leftActive then
	--		r2 = r2 + xl
	--	else
	--		r2 = r2 - xr
	--	end
	--	print(tostring(r1).." "..tostring(r2).." "..tostring(z1).." "..tostring(of).." "..tostring(x1))
	--	if r2 < r1 then
	--		r2 = r1
	--	end
	--
	--	if     toolParam.limitOutside and toolParam.limitInside then
	--		a2 = AIVEUtils.clamp(  math.atan( vehicle.aiveChain.wheelBase / r2 ), vehicle.aiveChain.minLooking, a2 )
	--		a1 = math.min( a1, a2 )
	--	elseif toolParam.limitOutside then
	--		a1 = AIVEUtils.clamp(  math.atan( vehicle.aiveChain.wheelBase / r2 ), vehicle.aiveChain.minLooking, a1 )
	--	end
	--end

		toolParam.x        = x1
		toolParam.z        = z1
		toolParam.zBack    = zb
		toolParam.nodeBack = tool.marker[ib]
		toolParam.nodeLeft = tool.marker[il]
		toolParam.nodeRight= tool.marker[ir]
		toolParam.b1       = z1
		toolParam.b2       = 0
		toolParam.b3       = 0
		toolParam.offset   = offset
		toolParam.width    = width
		toolParam.angle    = 0
		toolParam.minRaduis= r1
		toolParam.refAngle = a1
		toolParam.refAngle2= a2

	end

	if vehicle.aiveChain.leftActive then
		toolParam.minAngle = -math.min(toolParam.refAngle2, maxLooking )
		toolParam.maxAngle = math.min( toolParam.refAngle,  maxLooking )
	else
		toolParam.minAngle = -math.min(toolParam.refAngle,  maxLooking )
		toolParam.maxAngle = math.min( toolParam.refAngle2, maxLooking )
	end

	local wx,wy,wz = worldDirectionToLocal(vehicle.aiveChain.refNode, 0, 1, 0)
	local cf = math.abs( wy )
	toolParam.x        = toolParam.x      * cf
	toolParam.offset   = toolParam.offset * cf
	toolParam.width    = toolParam.width  * cf

	-- width is always left - right
	if vehicle.aiveChain.leftActive then
	-- toolParam.x is left marker (the biggest one) => l - ( l - r ) = l - l + r = r
		toolParam.xOther = toolParam.x - toolParam.width
	else
	-- toolParam.x is right marker => r + l - r = l
		toolParam.xOther = toolParam.x + toolParam.width
	end

	return toolParam
end

------------------------------------------------------------------------
-- setChainStatus
------------------------------------------------------------------------
function AutoSteeringEngine.setChainStatus( vehicle, startIndex, newStatus )
	if newStatus > AIVEStatus.initial and AutoSteeringEngine.skipIfNotServer( vehicle ) then
		return
	end

	if vehicle.aiveChain ~= nil and vehicle.aiveChain.nodes ~= nil then
		local i = math.max(startIndex,1)
		while i <= vehicle.aiveChain.chainMax + 1 do
			if vehicle.aiveChain.nodes[i].status > newStatus then
				vehicle.aiveChain.nodes[i].status = newStatus
				vehicle.aiveChain.nodes[i].tool   = {}
			end
			i = i + 1
		end
	end
end

------------------------------------------------------------------------
-- initSteering
------------------------------------------------------------------------
function AutoSteeringEngine.initSteering( vehicle )

	if AutoSteeringEngine.skipIfNotServer( vehicle ) then return en


�िए बिल्कुल सही: भारी उम्रदराज़ रिकॉर्ड चरित्र

4. लो-फाई एंबिएंट
   - Pops/min: 12, Pop Level: 3.5, Crackles/min: 80, Crackle Level: 4.0, Rumble: -42dB, Crosstalk: -38dB, Noise Profile: 6.0, Wear: 50%, Mix: 60%
   - इसके लिए बिल्कुल सही: पृष्ठभूमि परिवेशी बनावट

5. डायनामिक विनाइल सिमुलेशन
   - Pops/min: 25, Pop Level: 5.0, Crackles/min: 180, Crackle Level: 6.0, Rumble: -32dB, Crosstalk: -28dB, Noise Profile: 5.5, Wear: 100%, Mix: 95%
   - इसके लिए बिल्कुल सही: पूर्ण विनाइल रिकॉर्ड अनुभव

याद रखें: ये प्रभाव आपके संगीत में चरित्र और नॉस्टैल्जिया जोड़ने के लिए हैं। सूक्ष्म सेटिंग्स से शुरू करें और स्वाद के अनुसार समायोजित करें!
# Modulation Plugins

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

## Список плагинов

- [Doppler Distortion](#doppler-distortion) - Симулирует естественные, динамические изменения звука, вызванные легким движением конуса динамика.
- [Pitch Shifter](#pitch-shifter) - Изменяет тональность вашей музыки, не влияя на скорость воспроизведения
- [Tremolo](#tremolo) - Создает ритмические изменения громкости для пульсирующего, динамичного звука
- [Wow Flutter](#wow-flutter) - Воссоздает нежные изменения высоты тона, характерные для виниловых пластинок и магнитофонов

## Doppler Distortion

Ощутите уникальный аудиоэффект, который привносит нотку естественного движения в вашу музыку. Doppler Distortion симулирует нежные искажения, создаваемые физическим движением конуса динамика. Этот эффект вносит незначительные изменения в глубину и тембр звука, подобно привычным сдвигам тона, которые вы слышите, когда источник звука движется относительно вас. Он придает вашему прослушиванию дин


s.game:DisableSpawnLocation(self.id, self.Properties.bInitialSpawn);
		end
	else
		if (enable) then
			g_gameRules.game:AddSpawnLocation(self.id, self.Properties.bInitialSpawn, self.Properties.bDoVisTest, self.Properties.groupName);
		else
			g_gameRules.game:RemoveSpawnLocation(self.id, self.Properties.bInitialSpawn);
		end
	end
	self.enabled=enable;
end

--------------------------------------------------------------------------
function SpawnPoint:OnPropertyChange()
	self:Enable(tonumber(self.Properties.bEnabled)~=0);
end

--------------------------------------------------------------------------
function SpawnPoint.Server:OnShutDown()
	if (g_gameRules) then
		g_gameRules.game:RemoveSpawnLocation(self.id, self.Properties.bInitialSpawn);
	end
end

--------------------------------------------------------------------------
function SpawnPoint.Client:OnShutDown()
	if (g_gameRules) and (not CryAction.IsServer()) then
		g_gameRules.game:RemoveSpawnLocation(self.id, self.Properties.bInitialSpawn);
	end
end

--------------------------------------------------------------------------
function SpawnPoint:Spawned(entity)
	self:ActivateOutput("Spawn", entity.id);
end

--------------------------------------------------------------------------
function SpawnPoint:IsEnabled()
	return self.enabled;
end

--------------------------------------------------------------------------
-- Event is generated when something is spawned using this spawnpoint
--------------------------------------------------------------------------
function SpawnPoint:Event_Spawn()

	if(g_localActor == nil)then
		return;
	end

	local player = g_localActor;
	player:SetWorldPos(self:GetWorldPos(g_Vectors.temp_v1));

	self:GetAngles(g_Vectors.temp_v1);
	g_Vectors.temp_v1.x = 0;
	g_Vectors.temp_v1.y = 0;
	player.actor:PlayerSetViewAngles( g_Vectors.temp_v1 );

	self:ActivateOutput("Spawn", player.id);
end

function SpawnPoint:Event_Enable()
	self:Enable(true);
	BroadcastEvent(self, "Enabled");
end

function SpawnPoint:Event_Disable()
	self:Enable(false);
	BroadcastEvent(self, "Disabled");
end

SpawnPoint.FlowEvents =
{
	Inputs =
	{
		Spawn = { SpawnPoint.Event_Spawn, "bool" },
		Enable = { SpawnPoint.Event_Enable, "bool" },
		Disable = { SpawnPoint.Event_Disable, "bool" },
	},
	Outputs =
	{
		Spawn = "entity",
		Enabled = "bool",
		Disabled = "bool",
	},
}


tProp	: "순서있는 목록 속성",
DlgLstStart			: "Start",	//MISSING
DlgLstType			: "종류",
DlgLstTypeCircle	: "원(Circle)",
DlgLstTypeDisc		: "Disc",	//MISSING
DlgLstTypeSquare	: "네모점(Square)",
DlgLstTypeNumbers	: "번호 (1, 2, 3)",
DlgLstTypeLCase		: "소문자 (a, b, c)",
DlgLstTypeUCase		: "대문자 (A, B, C)",
DlgLstTypeSRoman	: "로마자 수문자 (i, ii, iii)",
DlgLstTypeLRoman	: "로마자 대문자 (I, II, III)",

// Document Properties Dialog
DlgDocGeneralTab	: "일반",
DlgDocBackTab		: "배경",
DlgDocColorsTab		: "색상 및 여백",
DlgDocMetaTab		: "메타데이터",

DlgDocPageTitle		: "페이지명",
DlgDocLangDir		: "문자 쓰기방향",
DlgDocLangDirLTR	: "왼쪽에서 오른쪽 (LTR)",
DlgDocLangDirRTL	: "오른쪽에서 왼쪽 (RTL)",
DlgDocLangCode		: "언어코드",
DlgDocCharSet		: "캐릭터셋 인코딩",
DlgDocCharSetCE		: "Central European",	//MISSING
DlgDocCharSetCT		: "Chinese Traditional (Big5)",	//MISSING
DlgDocCharSetCR		: "Cyrillic",	//MISSING
DlgDocCharSetGR		: "Greek",	//MISSING
DlgDocCharSetJP		: "Japanese",	//MISSING
DlgDocCharSetKR		: "Korean",	//MISSING
DlgDocCharSetTR		: "Turkish",	//MISSING
DlgDocCharSetUN		: "Unicode (UTF-8)",	//MISSING
DlgDocCharSetWE		: "Western European",	//MISSING
DlgDocCharSetOther	: "다른 캐릭터셋 인코딩",

DlgDocDocType		: "문서 헤드",
DlgDocDocTypeOther	: "다른 문서헤드",
DlgDocIncXHTML		: "XHTML 문서정의 포함",
DlgDocBgColor		: "배경색상",
DlgDocBgImage		: "배경이미지 URL",
DlgDocBgNoScroll	: "스크롤되지않는 배경",
DlgDocCText			: "텍스트",
DlgDocCLink			: "링크",
DlgDocCVisited		: "방문한 링크(Visited)",
DlgDocCActive		: "활성화된 링크(Active)",
DlgDocMargins		: "페이지 여백",
DlgDocMaTop			: "위",
DlgDocMaLeft		: "왼쪽",
DlgDocMaRight		: "오른


Press ? "Key press" : "Key release")
              << ' ' << ke->text() << " on " << o << " key grabber " << QWidget::keyboardGrabber();
            m_logEdit->appendPlainText(message);
        }
            break;
        default:
            break;
        }
    }
    return QMainWindow::eventFilter(o ,e);
}

void MainWindow::showModalDialog()
{
    QMessageBox::information(this, QLatin1String("Information"), QLatin1String("Modal Dialog"));
}

void MainWindow::toggleMouseWidgetGrab(QWidget *w, bool on)
{
    if (on) {
        m_logEdit->appendPlainText(w->objectName() + QLatin1String(" grabbed mouse."));
        w->grabMouse();
    } else {
        w->releaseMouse();
        m_logEdit->appendPlainText(w->objectName() + QLatin1String(" released mouse."));
    }
}

void MainWindow::toggleKeyboardWidgetGrab(QWidget *w, bool on)
{
    if (on) {
        m_logEdit->appendPlainText(w->objectName() + QLatin1String(" grabbed keyboard."));
        w->grabKeyboard();
    } else {
        w->releaseKeyboard();
        m_logEdit->appendPlainText(w->objectName() + QLatin1String(" released keyboard."));
    }
}

void MainWindow::mouseGrabToggled(bool g)
{
    toggleMouseWidgetGrab(m_grabMouseCheckBox, g);
}

void MainWindow::delayedMouseGrab()
{
    QTimer::singleShot(2000, m_grabMouseCheckBox, SLOT(animateClick()));
}

void MainWindow::grabMouseWindowToggled(bool g)
{
    toggleMouseWidgetGrab(this, g);
}

void MainWindow::delayedMouseWindowGrab()
{
    QTimer::singleShot(2000, m_grabMouseWindowCheckBox, SLOT(animateClick()));
}

void MainWindow::keyboardGrabToggled(bool g)
{
    toggleKeyboardWidgetGrab(m_grabKeyboardCheckBox, g);
}

void MainWindow::grabKeyboardWindowToggled(bool g)
{
    toggleKeyboardWidgetGrab(this, g);
}

void MainWindow::forceNativeWidgets()
{
    const WId platformWid = m_forceNativeButton->winId();
#if QT_VERSION < 0x050000 && defined(Q_OS_WIN)
    const quintptr wid = quintptr(platformWid); // HWND on Qt 4.8/Windows.
#else
    const WId wid = platformWid;
#endif
    m_logEdit->appendPlainText(QString::fromLatin1("Created native widget %1").arg(wid));
    m_forceNativeButton->setEnabled(false);
    m_forceNativeButton->setText(QLatin1String("Native widgets created"));
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

#include "main.moc"
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following in


  @Override
public boolean isConnected() {
    return this.connected;
  }

  @Override
public synchronized void clear() {
    synchronized(list) {
      list.clear();
    }
    points = new TrailPoint[0];
    ghostPoint.xp = Double.NaN;
  }

  @Override
public void setXLabel(String _label) {
    inputLabels[0] = _label;
  }

  @Override
public void setYLabel(String _label) {
    inputLabels[1] = _label;
  }

  @Override
public void setZLabel(String _label) {
    inputLabels[2] = _label;
  }

  private void addPoint(double _x, double _y, double _z, boolean _c) {
    synchronized(list) {
      if((maximum>0)&&(list.size()>=maximum)) {
        list.remove(0);
      }
      TrailPoint point = new TrailPoint(_x, _y, _z, _c);
      list.add(point);
      if(getDrawingPanel3D()!=null) {
        point.transformAndProject();
      }
    }
  }

  public int getNumberOfPoints() {
    return list.size();
  }

  @Override
public void setGhostPoint(double[] _point, boolean _connected) {
    if(_point==null) {
      ghostPoint.xp = Double.NaN;
    } else {
      ghostPoint.xp = _point[0];
      ghostPoint.yp = _point[1];
      ghostPoint.zp = _point[2];
      ghostPoint.connected = _connected;
      if(getDrawingPanel3D()!=null) {
        ghostPoint.transformAndProject();
      }
    }
  }

  // -------------------------------------
  // Abstract part of Element or Parent methods overwritten
  // -------------------------------------
  private void preparePoints() {
    boolean hasGhost = !Double.isNaN(ghostPoint.xp);
    int n = hasGhost ? list.size()+1 : list.size();
    points = new TrailPoint[n];
    int index = 0;
    for(TrailPoint point : list) {
      points[index] = point;
      point.setIndex(index);
      index++;
    }
    if(hasGhost) {
      points[index] = ghostPoint;
      ghostPoint.setIndex(index);
    }
  }

  @Override
Object3D[] getObjects3D() {
    synchronized(list) {
      if(!isReallyVisible()||(list.size()<=0)) {
        return null;
      }
      preparePoints();
    }
    if(hasChanged()) {
      transformAndProjectPoints();
    } else if(needsToProject()) {
      projectPoints();
    }
    return points;
  }

  @Override
void draw(Graphics2D _g2, int _index) {
    TrailPoint point = points[_index];
    Color theColor = getDrawingPanel3D().projectColor(getRealStyle().getLineColor(), point.getDistance());
    _g2.setStroke(getRealStyle().getLineStroke());
    _g2.setColor(theColor);
    if((_index==0)||!point.connected) {
      _g2.drawLine((int) point.pixel[0], (int) point.pixel[1], (int) point.pixel[0], (int) point.pixel[1]);
    } else {
      TrailPoint pointPrev = points[_index-1];
      _g2.drawLine((int) point.pixel[0], (int) point.pixel[1], (int) pointPrev.pixel[0], (int) pointPrev.pixel[1]);
    }
  }

  @Override
void drawQuickly(Graphics2D _g2) {
    synchronized(list) {
      if(!isReallyVisible()||(list.size()<=0)) {
        return;
      }
      pre


aredMessage.class);
    assertEquals("test message", message.getMessage());
    assertEquals("123.456", message.getThreadTimestamp());
    assertTrue(message.isUnfurl());
    assertTrue(message.isLinkNames());
    assertTrue(message.isReplyBroadcast());
    assertNotNull(message.getBlocks());
    assertEquals(8, message.getBlocks().size());
    assertEquals(BlockType.CONTEXT.getType(), message.getBlocks().get(0).getType());
    assertEquals(1, message.getAttachments().size());
    assertEquals("test attachment", message.getAttachments().get(0).getText());
    assertEquals("attachment action", message.getAttachments().get(0).getActions().get(0).getName());

  }

}package com.ullink.slack.simpleslackapi;

import java.util.concurrent.TimeUnit;

import com.ullink.slack.simpleslackapi.replies.SlackReply;

public class SlackMessageHandle<T extends SlackReply> {

    private static final long WAIT_TIME_IN_MILLISECOND = 1L;
    private long                messageId;
    private volatile T          slackReply;

    public SlackMessageHandle(long messageId)
    {
        this.messageId = messageId;
    }

    public long getMessageId()
    {
        return messageId;
    }

    public T getReply()
    {
        return slackReply;
    }

    public void setReply(T slackReply)
    {
        this.slackReply = slackReply;
    }

    public boolean isAcked()
    {
        return false;
    }

    public void waitForReply(long timeout, TimeUnit unit)
    {
        long nanoStart = System.nanoTime();
        while ((System.nanoTime() - nanoStart) < unit.toNanos(timeout) && slackReply == null)
        {
            try
            {
                Thread.sleep(WAIT_TIME_IN_MILLISECOND);
            }
            catch (InterruptedException e)
            {
                return;
            }
        }
    }
}
package com.ullink.slack.simpleslackapi;

public class SlackChatConfiguration
{
    public enum Avatar
    {
        DEFAULT, EMOJI, ICON_URL
    }

    private boolean asUser;
    private Avatar  avatar = Avatar.DEFAULT;
    private String  userName;
    private String  avatarDescription;

    public boolean isAsUser()
    {
        return asUser;
    }

    public Avatar getAvatar()
    {
        return avatar;
    }

    public String getUserName()
    {
        return userName;
    }

    public String getAvatarDescription()
    {
        return avatarDescription;
    }

    public SlackChatConfiguration asUser()
    {
        asUser = true;
        avatar = Avatar.DEFAULT;
        avatarDescription = null;
        return this;
    }

    public SlackChatConfiguration withIcon(String iconURL)
    {
        asUser = false;
        avatar = Avatar.ICON_URL;
        avatarDescription = iconURL;
        return this;
    }

    public SlackChatConfiguration withName(String name)
    {
        asUser = false;
        userName = name;
        return this;
    }

    public SlackChatConfiguration withEmoji(String emoji)
    {
        asUser = false;
        avatar = Avatar.EMOJI;
        avatarDescription = emoji;
        return this;
    }

    public static SlackChatConfiguration getConfiguration()
    {
        return new SlackChatConfiguration();
    }

}
package com.ullink.slack.simpleslackapi.blocks;

import com.google.gson.Gson;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google


.mergeFromJson(i, r);

  static final $pb.BuilderInfo _i = $pb.BuilderInfo(
      _omitMessageNames ? '' : 'CreateRoleRequest',
      package:
          const $pb.PackageName(_omitMessageNames ? '' : 'google.iam.admin.v1'),
      createEmptyInstance: create)
    ..aOS(1, _omitFieldNames ? '' : 'parent')
    ..aOS(2, _omitFieldNames ? '' : 'roleId')
    ..aOM<Role>(3, _omitFieldNames ? '' : 'role', subBuilder: Role.create)
    ..hasRequiredFields = false;

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

  $pb.BuilderInfo get info_ => _i;

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

  ///  The `parent` parameter's value depends on the target resource for the
  ///  request, namely
  ///  [`projects`](https://cloud.google.com/iam/reference/rest/v1/projects.roles)
  ///  or
  ///  [`organizations`](https://cloud.google.com/iam/reference/rest/v1/organizations.roles).
  ///  Each resource type's `parent` value format is described below:
  ///
  ///  * [`projects.roles.create()`](https://cloud.google.com/iam/reference/rest/v1/projects.roles/create):
  ///    `projects/{PROJECT_ID}`. This method creates project-level
  ///    [custom
  ///    roles](https://cloud.google.com/iam/docs/understanding-custom-roles).
  ///    Example request URL:
  ///    `https://iam.googleapis.com/v1/projects/{PROJECT_ID}/roles`
  ///
  ///  * [`organizations.roles.create()`](https://cloud.google.com/iam/reference/rest/v1/organizations.roles/create):
  ///    `organizations/{ORGANIZATION_ID}`. This method creates organization-level
  ///    [custom
  ///    roles](https://cloud.google.com/iam/docs/understanding-custom-roles).
  ///    Example request URL:
  ///    `https://iam.googleapis.com/v1/organizations/{ORGANIZATION_ID}/roles`
  ///
  ///  Note: Wildcard (*) values are invalid; you must specify a complete project
  ///  ID or organization ID.
  @$pb.TagNumber(1)
  $core.String get parent => $_getSZ(0);
  @$pb.TagNumber(1)
  set parent($core.String v) {
    $_setString(0, v);
  }

  @$pb.TagNumber(1)
  $core.bool hasParent() => $_has(0);
  @$pb.TagNumber(1)


   alignment: Alignment.center,
              child: Text("背景内容区域"),
            )
          ],
        ));
  }
}

import 'package:bruno/bruno.dart';
import 'package:flutter/material.dart';

class SelectionViewDateRangeExamplePage extends StatefulWidget {
  final String _title;
  final List<BrnSelectionEntity>? _filterData;

  SelectionViewDateRangeExamplePage(this._title, this._filterData);

  @override
  _SelectionViewExamplePageState createState() =>
      _SelectionViewExamplePageState();
}

class _SelectionViewExamplePageState
    extends State<SelectionViewDateRangeExamplePage> {
  List<BrnSelectionEntity>? items;

  BrnSelectionViewController? controller;

  @override
  void initState() {
    super.initState();

    controller = BrnSelectionViewController();
  }

  @override
  void dispose() {
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: BrnAppBar(title: widget._title),
      body: SingleChildScrollView(
          child: Column(
        children: <Widget>[
          Container(
            padding: EdgeInsets.only(top: 20),
            alignment: Alignment.center,
            child: GestureDetector(
              child: Text("点击关闭弹窗"),
              onTap: () {
                controller!.closeSelectionView();
              },
            ),
          ),
          BrnSelectionView(
            selectionViewController: controller,
            originalSelectionData: widget._filterData!,
            onSelectionChanged: (int menuIndex,
                Map<String, String> filterParams,
                Map<String, String> customParams,
                BrnSetCustomSelectionMenuTitle setCustomTitleFunction) {
              BrnToast.show(filterParams.toString(), context);
            },
            onSelectionPreShow: (int index, BrnSelectionEntity entity) {
              if (entity.key == 'date_11' || entity.key == 'date_22') {
                return BrnSelectionWindowType.range;
              }
              return entity.filterShowType!;
            },
          ),
          Container(
            padding: EdgeInsets.only(top: 300),
            alignment: Alignment.center,
            child: Text("背景内容区域"),
          ),
        ],
      )),
    );
  }
}

import 'package:bruno/bruno.dart';
import 'package:flutter/material.dart';

class SelectionViewCloseOrInterceptorExamplePage extends StatefulWidget {
  final String _title;
  final List<BrnSelectionEntity>? _filterData;

  SelectionViewCloseOrInterceptorExamplePage(this._title, this._filterData);

  @override
  _SelectionViewExamplePageState createState() =>
      _SelectionViewExamplePageState();
}

class _SelectionViewExamplePageState
    extends State<SelectionViewCloseOrInterceptorExamplePage> {
  List<BrnSelectionEntity>? items;

  BrnSelectionViewController? controller;

  @override
  void initState() {
    super.initState();

    controller = BrnSelectionViewController();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: BrnAppBar(title: widget._title),
      body: SingleChildScrollView(
          child: Column(
        children: <Widget>[
          Container(
            padding: EdgeInsets.only(top: 20),
            alignment: Alignment.center,
            child: GestureDetector(
              child: Text("点击关闭弹窗"),
              onTap: () {
                controller!.closeSelectionView();
              },
            ),
          ),
          Container(
            padding: EdgeInsets.only(top: 20),
            alignment: Alignment.center,
            child: GestureDetector(
              child: Text("点击刷新筛选 Title， 清除【双列】Filter 项"),
              onTap: () {
                widget._filterData![1].configRelationshipAndDefaultValue();
                widget._filterData![1].clearChildSelection();
                controller!.refreshSelectionTitle();
              },
            ),
          ),
          Brn


a b=\"   \n🙂\" />;\n", "/* @__PURE__ */ React.createElement(\"a\", { b: \"   \\n🙂\" });\n")
	expectPrintedJSX(t, "", ";\n", "/* @__PURE__ */ React.createElement(\"a\", { b: \"\\n   🙂\" });\n")

	expectPrintedJSX(t, "   b", "   b;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"   b\");\n")
	expectPrintedJSX(t, "   \nb", "   \nb;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b\");\n")
	expectPrintedJSX(t, "\n   b", "\n   b;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b\");\n")
	expectPrintedJSX(t, "b   ", "b   ;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b   \");\n")
	expectPrintedJSX(t, "b   \n", "b   \n;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b\");\n")
	expectPrintedJSX(t, "b\n   ", "b\n   ;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b\");\n")
	expectPrintedJSX(t, "b   c", "b   c;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b   c\");\n")
	expectPrintedJSX(t, "b   \nc", "b   \nc;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b c\");\n")
	expectPrintedJSX(t, "b\n   c", "b\n   c;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b c\");\n")
	expectPrintedJSX(t, "   b", "   b;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"   b\");\n")
	expectPrintedJSX(t, "   \nb", "   \nb;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b\");\n")
	expectPrintedJSX(t, "\n   b", "\n   b;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"b\");\n")

	// Same test as above except with multi-byte Unicode characters
	expectPrintedJSX(t, "   🙂", "   🙂;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"   🙂\");\n")
	expectPrintedJSX(t, "   \n🙂", "   \n🙂;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"🙂\");\n")
	expectPrintedJSX(t, "\n   🙂", "\n   🙂;\n", "/* @__PURE__ */ React.createElement(\"a\", null, \"🙂\");\n")
	expectPrintedJSX(t, "🙂   ", "🙂   ;\n",


#!/usr/bin/python3
def roman_to_int(roman_string):
    if not isinstance(roman_string, str) or roman_string is None:
        return 0

    roman_dict = {
        'I': 1, 'V': 5, 'X': 10,
        'L': 50, 'C': 100, 'D': 500, 'M': 1000
    }

    total = 0
    prev_value = 0

    for char in reversed(roman_string):
        value = roman_dict[char]
        if value < prev_value:
            total -= value
        else:
            total += value
        prev_value = value

    return total


/* apt-dater - terminal-based remote package update manager
 *
 * Authors:
 *   Thomas Liske <liske@ibh.de>
 *
 * Copyright Holder:
 *   2009-2015 (C) IBH IT-Service GmbH [https://www.ibh.de/apt-dater/]
 *
 * License:
 *   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 package; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */

#ifndef _ENV_H
#define _ENV_H

#include "apt-dater.h"
#include "history.h"

void
env_init(gchar **envp);

gchar **
env_build(HostNode *n, const gchar *action, const gchar *param, const HistoryEntry *he);

#endif /* _ENV_H */


->ApplyLightBlur(canvas, image, para);

    filter->lightBlurResultCache_[0] = std::make_shared<Drawing::Image>();
    filter->lightBlurResultCache_[1] = std::make_shared<Drawing::Image>();
    filter->ClearLightBlurResultCache();
    EXPECT_EQ(filter->lightBlurResultCache_[0], nullptr);
    EXPECT_EQ(filter->lightBlurResultCache_[1], nullptr);
}

/**
 * @tc.name: TestFormatCOLORTYPE_RGB_565_ALPHATYPE_OPAQUE
 * @tc.desc: Verify function ApplyLightBlur and ClearLightBlurResultCache
 * @tc.type:FUNC
 * @tc.require: issuesIBZ4YD
 */
HWTEST_F(RSLightBlurShaderFilterTest, TestFormatCOLORTYPE_RGB_565_ALPHATYPE_OPAQUE, TestSize.Level1)
{
    Drawing::Bitmap bitmap;
    Drawing::BitmapFormat format { Drawing::COLORTYPE_RGB_565, Drawing::ALPHATYPE_OPAQUE };
    bitmap.Build(10, 10, format);
    std::shared_ptr<Drawing::Image> image = std::make_shared<Drawing::Image>();
    EXPECT_TRUE(image->BuildFromBitmap(bitmap));
    int radius = 1;
    auto filter = std::make_shared<RSLightBlurShaderFilter>(radius);
    ASSERT_NE(filter, nullptr);
    Drawing::Canvas canvas;
    Drawing::Rect src(0, 0, 5, 5);
    Drawing::Rect dst(0, 0, 5, 5);
    LightBlurParameter para { src, dst, Drawing::Brush() };
    EXPECT_EQ(filter->GetRadius(), 1);
    filter->ApplyLightBlur(canvas, image, para);

    filter->lightBlurResultCache_[0] = std::make_shared<Drawing::Image>();
    filter->lightBlurResultCache_[1] = std::make_shared<Drawing::Image>();
    filter->ClearLightBlurResultCache();
    EXPECT_EQ(filter->lightBlurResultCache_[0], nullptr);
    EXPECT_EQ(filter->lightBlurResultCache_[1], nullptr);
}

/**
 * @tc.name: TestFormatCOLORTYPE_ARGB_4444_ALPHATYPE_OPAQUE
 * @tc.desc: Verify function ApplyLightBlur and ClearLightBlurResultCache
 * @tc.type:FUNC
 * @tc.require: issuesIBZ4YD
 */
HWTEST_F(RSLightBlurShaderFilterTest, TestFormatCOLORTYPE_ARGB_4444_ALPHATYPE_OPAQUE, TestSize.Level1)
{
    Drawing::Bitmap bitmap;
    Drawing::BitmapFormat format { Drawing::COLORTYPE_ARGB_4444, Drawing::ALPHATYPE_OPAQUE };
    bitmap.Build(10, 10, format);
    std::shared_ptr<Drawing::Image> image = std::make_shared<Drawing::Image>();
    EXPECT_TRUE(image->BuildFromBitmap(bitmap));
    int radius = 1;
    auto filter = std::make_shared<RSLightBlurShaderFilter>(radius);
    ASSERT_NE(filter, nullptr);
    Drawing::Canvas canvas;
    Drawing::Rect src(0, 0, 5, 5);
    Drawing::Rect dst(0, 0, 5, 5);
    LightBlurParameter para { src, dst, Drawing::Brush() };
    EXPECT_EQ(filter->GetRadius(), 1);
    filter->ApplyLightBlur(canvas, image, para);

    filter->lightBlurResultCache_[0] = std::make_shared<Drawing::Image>();
    filter->lightBlurResultCache_[1] = std::make_shared<Drawing::Image>();
    filter->ClearLightBlurResultCache();
    EXPECT_EQ(filter->lightBlurResultCache_[0], nullptr);
    EXPECT_EQ(filter->lightBlurResultCache_[1], nullptr);
}

/**
 * @tc.name: TestFormatCOLORTYPE_BGRA_8888_ALPHATYPE_OPAQUE
 * @tc.desc: Veri


import os
import uuid
import tempfile
import pytest
import pandas as pd
from sqlxport.core.storage import upload_file_to_s3
from sqlxport.utils.env import load_s3_config

@pytest.mark.skipif(
    not os.path.exists("tests/.env.test"),
    reason="Missing tests/.env.test config file"
)
def test_upload_file_to_s3_real():
    config = load_s3_config()

    # Create a dummy Parquet file
    df = pd.DataFrame({"name": ["Alice", "Bob"], "age": [30, 25]})
    with tempfile.NamedTemporaryFile(suffix=".parquet", delete=False) as tmpfile:
        df.to_parquet(tmpfile.name)
        local_path = tmpfile.name

    s3_key = f"test-upload/{uuid.uuid4()}.parquet"

    # Upload file to S3
    upload_file_to_s3(
        file_path=local_path,
        bucket_name=config["S3_BUCKET"],
        object_key=s3_key,
        access_key=config["AWS_ACCESS_KEY_ID"],
        secret_key=config["AWS_SECRET_ACCESS_KEY"],
        endpoint_url=config["S3_ENDPOINT_URL"],
        region_name=config["AWS_REGION"]
    )

    print(f"✅ Upload succeeded: s3://{config['S3_BUCKET']}/{s3_key}")


deg); -o-transform:rotate(180deg); -webkit-transform:rotate(180deg); transform:rotate(180deg);}
#main.sideBarHide .sideBar .sideBarShowHide a{*background:url(../images/ll.png);}
#main.sideBarHide .sideBar .sideBarShowHide a:hover{*background-position:0 -31px;}
#main.sideBarHide .sideBar .sideBarShowHide{background:none;}

.resultArea{float:left;width:100%;}
.resultArea .resultTotal{position:relative;padding-left:30px;margin-bottom:20px;}
.resultArea .resultTotal .info{color:#9a9a9a;}
.resultArea .resultTotal .orderOpt{position:absolute;right:50px;}
.resultArea .resultTotal .orderOpt a{margin-right:10px;color:#0080cc;}

/*搜索结果列表区域*/
.resultArea .resultList{padding-left:30px;}
.resultArea .resultList .resultItem{margin-bottom:20px;}
.resultArea .resultList .resultItem{margin-bottom:30px;}
.resultArea .resultList .itemHead{margin-bottom:5px;color:#767676;}
.resultArea .resultList .itemHead .keyWord{color:#d90909;}
.resultArea .resultList .itemBody .keyWord{color:#d90909;}
.resultArea .resultList .itemHead a.title{font-size:16px;color:#0080cc;text-decoration:underline;}
.resultArea .resultList .itemHead .value{color:#41D1B4;}
.resultArea .resultList .itemHead .divsion{margin:0 5px;}
.resultArea .resultList .itemHead .fileType{margin-right:10px;}

/*搜索内容主体*/
.resultArea .resultList .itemBody{margin-bottom:5px;line-height:18px;width:90%;}
.resultArea .resultList .itemFoot{color:#41D1B4;}
.resultArea .resultList .itemFoot .info{margin-right:10px;}

.resultArea .pagination{margin-bottom:25px;padding-left:32px;}
/*相关搜索*/
.resultArea .dependSearch{margin-bottom:30px;padding-left:32px;font-size:14px;}
.resultArea .dependSearch h6{float:left;margin-right:15px;font-weight:bold;}
.resultArea .dependSearch p{margin-bottom:5px;}
.resultArea .dependSearch a{display:inline-block;margin-right:15px;text-decoration:underline;width:90px; white-space:nowrap; overflow:hidden;text-overflow:ellipsis;}
.resultArea .searchInResult{padding-left:35px;}
.resultArea .searchInResult .inResult{position:absolute;right:-190px;top:8px;font-size:14px;text-decoration:underline;}
.resultArea .searchInResult .searchButton{left:417px;}
/*历史搜索区域*/
.historyArea{float:right;margin-right:-212px;width:212px;}
.historyArea h6{margin-bottom:10px;font-weight:bold;}
.historyArea .historyList{margin-bottom:20px;}
.historyArea .historyList li{margin-bottom:5px;}

/*左侧分栏区域*/
.subfield{margin-bottom:5px;font-size:14px;font-weight:bold;padding:2px 0 2px 24px;}
.subfield:first-child{border-left:4px solid #41D1B4;padding-left:20px;}

/*立即搜索样式*/
.subfieldContent .search{margin:45px


xes for 8 seconds"]={nil,"Every 16 seconds you gain iron Reflexes for 8 seconds "}c["20% increased Critical Strike Chance with Staves"]={{[1]={flags=2097156,keywordFlags=0,name="CritChance",type="INC",value=20}},nil}c["15% reduced Mana Cost of Channelling Skills"]={{[1]={flags=0,keywordFlags=0,name="ManaCost",type="INC",value=-15}},"  Channelling Skills "}c["10% more Physical Damage while at maximum Frenzy Charges"]={{[1]={[1]={stat="FrenzyCharges",thresholdStat="FrenzyChargesMax",type="StatThreshold"},flags=0,keywordFlags=0,name="PhysicalDamage",type="MORE",value=10}},nil}c["Enemies you Curse have Malediction"]={{[1]={flags=0,keywordFlags=0,name="AffectedByCurseMod",type="LIST",value={mod={flags=0,keywordFlags=0,name="DamageTaken",type="INC",value=10}}}},nil}c["Minions have 10% increased Area of Effect"]={{[1]={flags=0,keywordFlags=0,name="MinionModifier",type="LIST",value={mod={flags=0,keywordFlags=0,name="AreaOfEffect",type="INC",value=10}}}},nil}c["Nearby Enemies have Fire, Cold and Lighting Exposure while you have Phasing, applying -15% to those Resistances Nearby Enemies have 15% less Accuracy Rating while you have Phasing"]={nil,"Nearby Enemies have Fire, Cold and Lighting Exposure while you have Phasing, applying -15% to those Resistances Nearby Enemies have 15% less Accuracy Rating while you have Phasing "}c["Spells Cast by Totems have 5% increased Cast Speed"]={{[1]={flags=16,keywordFlags=16384,name="Speed",type="INC",value=5}},nil}c["8% increased Attack Physical Damage"]={{[1]={flags=1,keywordFlags=0,name="PhysicalDamage",type="INC",value=8}},nil}c["125% increased Armour and Energy Shield"]={{[1]={flags=0,keywordFlags=0,name="ArmourAndEnergyShield",type="INC",value=125}},nil}c["18% increased Intelligence"]={{[1]={flags=0,keywordFlags=0,name="Int",type="INC",value=18}},nil}c["Brands Attach to a new Enemy each time they Activate, no more than once every 0.3 seconds"]={nil,"Brands Attach to a new Enemy each time they Activate, no more than once every 0.3 seconds "}c["Minions deal 70% increased Damage"]={{[1]={flags=0,keywordFlags=0,name="MinionModifier",type="LIST",value={mod={flags=0,keywordFlags=0,name="Damage",type="INC",value=70}}}},nil}c["2% reduced Mana Reserved"]={{[1]={flags=0,keywordFlags=0,name="ManaReserved",type="INC",value=-2}},nil}c["You and your Minions have 1% additional Physical Damage Reduction for each Raised Zombie"]={nil,"You and your Minions have 1% additional Physical Damage Reduction for each Raised Zombie "}c["45% increased Damage"]={{[1]={flags=0,keywordFlags=0,name="Damage",type="INC",value=45}},nil}c["maximum Life per second for each Stage You and nearby Allies have 12% increased Movement Speed"]={nil,"maximum Life per second for each Stage You and nearby Allies have 12% increased Movement Speed "}c["Regenerate 15 Mana per Second while on Consecrated Ground"]={{[1]={[1]={type="Condition",var="OnConsecratedGround"},flags=0,keywordFlags=0,name="ManaRegen",type="BASE",value=15}},nil}c["8% increased Accuracy Rating with Two Handed Melee Weapons"]={{[1]={flags=301989892,keywordFlags=0,name="Accuracy",type="INC",value=8}},nil}c["14% Chance to


				import('astro/zod').ZodLiteral<'gif'>,
				import('astro/zod').ZodLiteral<'svg'>
			]
		>;
	}>;

	type BaseSchemaWithoutEffects =
		| import('astro/zod').AnyZodObject
		| import('astro/zod').ZodUnion<import('astro/zod').AnyZodObject[]>
		| import('astro/zod').ZodDiscriminatedUnion<string, import('astro/zod').AnyZodObject[]>
		| import('astro/zod').ZodIntersection<
				import('astro/zod').AnyZodObject,
				import('astro/zod').AnyZodObject
		  >;

	type BaseSchema =
		| BaseSchemaWithoutEffects
		| import('astro/zod').ZodEffects<BaseSchemaWithoutEffects>;

	export type SchemaContext = { image: ImageFunction };

	type DataCollectionConfig<S extends BaseSchema> = {
		type: 'data';
		schema?: S | ((context: SchemaContext) => S);
	};

	type ContentCollectionConfig<S extends BaseSchema> = {
		type?: 'content';
		schema?: S | ((context: SchemaContext) => S);
	};

	type CollectionConfig<S> = ContentCollectionConfig<S> | DataCollectionConfig<S>;

	export function defineCollection<S extends BaseSchema>(
		input: CollectionConfig<S>
	): CollectionConfig<S>;

	type AllValuesOf<T> = T extends any ? T[keyof T] : never;
	type ValidContentEntrySlug<C extends keyof ContentEntryMap> = AllValuesOf<
		ContentEntryMap[C]
	>['slug'];

	export function getEntryBySlug<
		C extends keyof ContentEntryMap,
		E extends ValidContentEntrySlug<C> | (string & {})
	>(
		collection: C,
		// Note that this has to accept a regular string too, for SSR
		entrySlug: E
	): E extends ValidContentEntrySlug<C>
		? Promise<CollectionEntry<C>>
		: Promise<CollectionEntry<C> | undefined>;

	export function getDataEntryById<C extends keyof DataEntryMap, E extends keyof DataEntryMap[C]>(
		collection: C,
		entryId: E
	): Promise<CollectionEntry<C>>;

	export function getCollection<C extends keyof AnyEntryMap, E extends CollectionEntry<C>>(
		collection: C,
		filter?: (entry: CollectionEntry<C>) => entry is E
	): Promise<E[]>;
	export function getCollection<C extends keyof AnyEntryMap>(
		collection: C,
		filter?: (entry: CollectionEntry<C>) => unknown
	): Promise<CollectionEntry<C>[]>;

	export function getEntry<
		C extends keyof ContentEntryMap,
		E extends ValidContentEntrySlug<C> | (string & {})
	>(entry: {
		collection: C;
		slug: E;
	}): E extends ValidContentEntrySlug<C>
		? Promise<CollectionEntry<C>>
		: Promise<CollectionEntry<C> | undefined>;
	export function getEntry<
		C extends keyof DataEntryMap,
		E extends keyof DataEntryMap[C] | (string & {})
	>(entry: {
		collection: C;
		id: E;
	}): E extends keyof DataEntryMap[C]
		? Promise<DataEntryMap[C][E]>
		: Promise<CollectionEntry<C> | undefined>;
	export function getEntry<
		C extends keyof ContentEntryMap,
		E extends ValidContentEntrySlug<C> | (string & {})
	>(
		collection: C,
		slug: E
	): E extends ValidContentEntrySlug<C>
		? Promise<CollectionEntry<C>>
		: Promise<CollectionEntry<C> | undefined>;
	export function getEntry<
		C ext


.LONG;
                        } else
                        if ( "float".equals(k)) {
                            g = TYPE.FLOAT;
                        } else
                        if ("double".equals(k)
                        ||  "number".equals(k)) {
                            g = TYPE.DOUBLE;
                        } else
                        {
                            g = TYPE.STRING;
                        }
                        break ;
                    case  "date" :
                        g = TYPE.LONG;
                        break ;
                    default:
                        g = TYPE.STRING;
                } else {
                        g = TYPE.STRING;
                }
            } else {
                f = "%" + f;
                if (null != t) switch(t) {
                    case "number":
                        if (   "int".equals(k)
                        ||    "byte".equals(k)
                        ||   "short".equals(k)) {
                            g = TYPE.INTS;
                        } else
                        if (  "long".equals(k)) {
                            g = TYPE.LONGS;
                        } else
                        if ( "float".equals(k)) {
                            g = TYPE.FLOATS;
                        } else
                        {
                            g = TYPE.DOUBLES;
                        }
                        break ;
                    case "hidden":
                    case  "enum" :
                        if (   "int".equals(k)
                        ||    "byte".equals(k)
                        ||   "short".equals(k)) {
                            g = TYPE.INTS;
                        } else
                        if (  "long".equals(k)) {
                            g = TYPE.LONGS;
                        } else
                        if ( "float".equals(k)) {
                            g = TYPE.FLOATS;
                        } else
                        if ("double".equals(k)
                        ||  "number".equals(k)) {
                            g = TYPE.DOUBLES;
                        } else
                        {
                            g = TYPE.STRINGS;
                        }
                        break ;
                    case  "date" :
                        g = TYPE.LONGS;
                        break ;
                    default:
                        g = TYPE.STRINGS;
                } else {
                        g = TYPE.STRINGS;
                }
            }

            Object o = getGatherField(g, f,n, m, rd);
            if (o instanceof Index) {
                indics.add( (Index) o );
            } else {
                dimens.add( (Dimen) o );
            }
        }

        return new Fields (
            dimens.toArray(new Dimen[dimens.size()]),
            indics.toArray(new Index[indics.size()])
        );
    }

    protected Object getGatherField(TYPE type, String field, String alias, String mode, Map rd) {
        // 维度
        if (null == mode) {
            return new StatisGather.Datum(type, field, alias);
        }

        // 指标
        switch (mode) {
        case "scope":
        case "range": {
            /**
             * 区间维度:
             * 从请求数据中
             * 提取区间列表
             */
            Set<String> rz = Dict.getValue (rd, Set.class, alias, Cnst.AR_KEY);
            if (null == rz ) rz = new LinkedHashSet();
            String [  ] rs = rz . toArray(new String [rz.size()]);
            return new StatisGather.Scope(type, field, alias, rs);
        }
        case "first":
            return new StatisGather.First(type, field, alias);
        case "flock":
            return new StatisGather.Flock(type, field, alias);
        case "crowd":
            return new StatisGather.Crowd(type, field, alias);
        case "count":
            return new StatisGather.Count(type, field, alias);
        case "tally":
            return new StatisGather.Tally(type, f


[Set Styles]]--

TidyPlatesThemeList["CP"].SetStyle = SetStyle
TidyPlatesThemeList["CP"].SetAlpha = SetAlpha
TidyPlatesThemeList["CP"].SetSpecialText = SetSpecialText
TidyPlatesThemeList["CP"].SetSpecialText3 = SetSpecialText3
TidyPlatesThemeList["CP"].SetPartyIcons = SetPartyIcons
TidyPlatesThemeList["CP"].SetPetIcons = SetPetIcons
TidyPlatesThemeList["CP"].SetSpecialArt = SetSpecialArt
TidyPlatesThemeList["CP"].SetScale = SetScale
TidyPlatesThemeList["CP"].SetHealthbarColor = SetHealthbarColor


.name),
                        onTap: () async {
                          try {
                            await musicProvider.addSongsToPlaylist(
                              playlist.id,
                              songs.map((s) => s.id).toList(),
                            );
                            Navigator.of(dialogContext).pop();
                            ScaffoldMessenger.of(context).showSnackBar(
                              SnackBar(content: Text('已将 ${songs.length} 首歌曲添加到 "${playlist.name}"')),
                            );
                            _toggleSelectionMode();
                          } catch (e) {
                            Navigator.of(dialogContext).pop();
                            ScaffoldMessenger.of(context).showSnackBar(
                              SnackBar(content: Text('添加到歌单失败: $e')),
                            );
                          }
                        },
                      );
                    },
                  ),
                ),
                ListTile(
                  leading: Icon(Icons.add_circle_outline),
                  title: Text('创建新歌单...'),
                  onTap: () async {
                    Navigator.of(dialogContext).pop();
                    _showCreatePlaylistAndAddMultipleSongsDialog(context, songs);
                  },
                )
              ],
            ),
          ),
          actions: [
            TextButton(
              child: Text('取消'),
              onPressed: () {
                Navigator.of(dialogContext).pop();
              },
            ),
          ],
        );
      },
    );
  }

  void _showCreatePlaylistAndAddMultipleSongsDialog(BuildContext context, List<Song> songs) {
    final TextEditingController playlistNameController = TextEditingController();
    final musicProvider = Provider.of<MusicProvider>(context, listen: false);

    showDialog(
      context: context,
      builder: (BuildContext dialogContext) {
        return AlertDialog(
          title: Text('创建新歌单并添加歌曲'),
          content: TextField(
            controller: playlistNameController,
            decoration: InputDecoration(hintText: '歌单名称'),
            autofocus: true,
          ),
          actions: [
            TextButton(
              child: Text('取消'),
              onPressed: () {
                Navigator.of(dialogContext).pop();
              },
            ),
            TextButton(
              child: Text('创建并添加'),
              onPressed: () async {
                final String name = playlistNameController.text.trim();
                if (name.isNotEmpty) {
                  try {
                    await musicProvider.createPlaylist(name);
                    dynamic newPlaylist;
                    for (var p in musicProvider.playlists) {
                      if (p.name == name) {
                        newPlaylist = p;
                        break;
                      }
                    }
                    if (newPlaylist != null) {
                      await musicProvider.addSongsToPlaylist(
                        newPlaylist.id,
                        songs.map((s) => s.id).toList(),
                      );
                      Navigator.of(dialogContext).pop();
                      ScaffoldMessenger.of(context).showSnackBar(
                        SnackBar(content: Text('已将 ${songs.length} 首歌曲添加到新歌单 "${newPlaylist.name}"')),
                      );
                      _toggleSelectionMode();
                    } else {
                      Navigator.of(dialogContext).pop();
                      ScaffoldMessenger.of(context).showSnackBar(
                        SnackBar(content: Text('创建播放列表后未能找到它。请确保名称唯一。')),
                      );
                    }
                  } catch (e) {
                    Navigator.


nce.YoAppearanceTexture;
import us.ihmc.simulationConstructionSetTools.util.ground.CombinedTerrainObject3D;
import us.ihmc.simulationconstructionset.ExternalForcePoint;
import us.ihmc.simulationconstructionset.Robot;
import us.ihmc.simulationconstructionset.util.ground.RotatableBoxTerrainObject;
import us.ihmc.simulationconstructionset.util.ground.TerrainObject3D;

public class FlatGroundEnvironment implements CommonAvatarEnvironmentInterface
{
   private final CombinedTerrainObject3D flatGround = new CombinedTerrainObject3D("flatGround");
   private final ArrayList<Robot> environmentRobots = new ArrayList<>();

   public FlatGroundEnvironment()
   {
      this(9, 9);
   }

   public FlatGroundEnvironment(int numberX, int numberY)
   {
      this(numberX, numberY, 0.0);
   }

   public FlatGroundEnvironment(double heightOffset)
   {
      this(9, 9, heightOffset);
   }

   public FlatGroundEnvironment(int numberX, int numberY, double heightOffset)
   {
      YoAppearanceTexture texture = new YoAppearanceTexture("Textures/ground2.png");
      double sizeXY = 50.0;

      for (int i = 0; i < numberX; i++)
      {
         for (int j = 0; j < numberY; j++)
         {
            Box3D box = new Box3D(sizeXY, sizeXY, 1.0);
            box.getPosition().setX(i * sizeXY - 0.5 * sizeXY * (numberX - 1));
            box.getPosition().setY(j * sizeXY - 0.5 * sizeXY * (numberY - 1));
            box.getPosition().setZ(-0.5 + heightOffset);
            flatGround.addTerrainObject(new RotatableBoxTerrainObject(box, texture));
         }
      }
   }

   public void addEnvironmentRobot(Robot robot)
   {
      environmentRobots.add(robot);
   }

   @Override
   public TerrainObject3D getTerrainObject3D()
   {
      return flatGround;
   }

   @Override
   public List<Robot> getEnvironmentRobots()
   {
      return environmentRobots;
   }

   @Override
   public void createAndSetContactControllerToARobot()
   {
   }

   @Override
   public void addContactPoints(List<? extends ExternalForcePoint> externalForcePoints)
   {
   }

   @Override
   public void addSelectableListenerToSelectables(SelectableObjectListener selectedListener)
   {
   }
}
package us.ihmc.simulationConstructionSetTools.util.environments;

import java.util.ArrayList;
import java.util.List;

import us.ihmc.euclid.referenceFrame.FramePose3D;
import us.ihmc.euclid.referenceFrame.ReferenceFrame;
import us.ihmc.graphicsDescription.appearance.YoAppearance;
import us.ihmc.simulationConstructionSetTools.robotController.ContactController;
import us.ihmc.simulationConstructionSetTools.util.ground.CombinedTerrainObject3D;
import us.ihmc.simulationconstructionset.ExternalForcePoint;
import us.ihmc.simulationconstructionset.Robot;
import us.ihmc.simulationconstructionset.util.ground.Contactable;
import us.ihmc.simulationconstructionset.util.ground.TerrainObject3D;

public class StairsUpAndDownEnvironment implements CommonAvatarEnvironmentInterface
{
   private final List<Robot> contactableRobots = new ArrayList<Robot>();
   private final CombinedTerrainObject3D combinedTerrainObject;
   private final ArrayList<ExternalForcePoint> contactPoints = new ArrayList<ExternalForcePoint>();

   private static final int totalStepsUp = 3;
   private static final int totalStepsDown = 3;
   private static final double stepUp


iNode">uiNode

Fields inherited from interface org.loboevolution.html.node.Node

ATTRIBUTE_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, DOCUMENT_POSITION_CONTAINED_BY, DOCUMENT_POSITION_CONTAINS, DOCUMENT_POSITION_DISCONNECTED, DOCUMENT_POSITION_FOLLOWING, DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC, DOCUMENT_POSITION_PRECEDING, DOCUMENT_TYPE_NODE, ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, NONE, NOTATION_NODE, PROCESSING_INSTRUCTION_NODE, TEXT_NODE

Constructor Summary

Constructors

Constructor

Description

NotationImpl()

Method Summary

<button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method


Kind {
        &self.0
    }

    /// Unwrap this error into its underlying type.
    pub fn into_kind(self) -> ErrorKind {
        *self.0
    }
}

/// The specific type of an error.
#[derive(Debug, Clone, PartialEq)]
pub enum ErrorKind {
    /// If we have multiple sub-errors, we can represent them as a super-error
    Multiple(Vec<GhostError>),
    /// returned on an attempt to handle an callback for a non-existent request
    RequestIdNotFound(String),
    /// Generic stringified errors
    Other(String),
    EndpointDisconnected,
    /// Hints that destructuring should not be exhaustive.
    ///
    /// This enum may grow additional variants, so this makes sure clients
    /// don't count on exhaustive matching. (Otherwise, adding a new variant
    /// could break existing code.)
    #[doc(hidden)]
    __Nonexhaustive,
}

impl std::error::Error for GhostError {
    /// The lower-level source of this error, if any.
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match *self.0 {
            _ => None,
        }
    }
}

impl std::fmt::Display for GhostError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match *self.0 {
            ErrorKind::Multiple(ref s) => write!(f, "Multiple {{{:?}}}", s),
            ErrorKind::RequestIdNotFound(ref s) => write!(f, "RequestIdNotFound {{{:?}}}", s),
            ErrorKind::Other(ref s) => write!(f, "Unknown error encountered: '{}'.", s),
            _ => unreachable!(),
        }
    }
}

impl From<Vec<GhostError>> for GhostError {
    fn from(m: Vec<GhostError>) -> Self {
        GhostError::new(ErrorKind::Multiple(m))
    }
}

impl From<String> for GhostError {
    fn from(s: String) -> Self {
        GhostError::new(ErrorKind::Other(s))
    }
}

impl From<&str> for GhostError {
    fn from(s: &str) -> Self {
        GhostError::new(ErrorKind::Other(s.to_string()))
    }
}

impl<T> From<crossbeam_channel::SendError<T>> for GhostError {
    fn from(e: crossbeam_channel::SendError<T>) -> Self {
        GhostError::new(ErrorKind::Other(format!("{:?}", e)))
    }
}
<reponame>jDomantas/plank<filename>plank-x86-backend/src/compiler.rs<gh_stars>10-100
use plank_ir::analysis::{self, Loc};
use plank_ir::ir::{
    BinaryOp, BitOp, Block, BlockEnd, BlockId, Function, Instruction, IntOp, Program, Reg,
    Signedness, Size, UnaryOp, Value,
};
use std::collections::{HashMap, HashSet};
use x86;

#[derive(Default, Debug, Clone)]
struct Constraints {
    intersect: HashSet<(Reg, Reg)>,
    not_flag: HashSet<Reg>,
    not_register: HashSet<Reg>,
}

#[derive(Debug, Copy, Clone)]
enum Bonus {
    SameLocation(Reg, Reg),
}

fn can_be_flag(reg: Reg, f: &Function, live: &HashSet<Loc>) -> bool {
    let mut got_assign = false;
    for (&id, block) in &f.blocks {
        for (index, op) in block.ops.iter().enumerate() {
            let loc = Loc {
                block: id,
                pos: index,
            };
            match *op {
                Instruction::BinaryOp(r, BinaryOp::IntOp(IntOp::Greater, _, _), _, _)
                | Instruction::BinaryOp(r, BinaryOp::IntOp(IntOp::GreaterEq, _, _), _, _)
                | Instruction::BinaryOp(r, BinaryOp::IntOp(IntOp::Less, _, _), _, _)
                | Instruction::BinaryOp(r, BinaryOp::IntOp(IntOp::LessEq, _, _), _, _)
                | Instruction::BinaryOp(r, BinaryOp::Eq, _, _)
                | Instruction::BinaryOp(r, BinaryOp::Neq, _, _)


/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2009 IITP RAS
 *
 * This program 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;
 *
 * 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
 *
 * Authors: Pavel Boyko <boyko@iitp.ru>, written after OlsrHelper by Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */

#ifndef AODV_HELPER_H
#define AODV_HELPER_H

#include "ns3/object-factory.h"
#include "ns3/node.h"
#include "ns3/node-container.h"
#include "ns3/ipv4-routing-helper.h"

namespace ns3
{
/**
 * \ingroup aodv
 * \brief Helper class that adds AODV routing to nodes.
 */
class AodvHelper : public Ipv4RoutingHelper
{
public:
  AodvHelper();

  /**
   * \internal
   * \returns pointer to clone of this OlsrHelper
   *
   * This method is mainly for internal use by the other helpers;
   * clients are expected to free the dynamic memory allocated by this method
   */
  AodvHelper* Copy (void) const;

  /**
   * \param node the node on which the routing protocol will run
   * \returns a newly-created routing protocol
   *
   * This method will be called by ns3::InternetStackHelper::Install
   *
   * TODO: support installing AODV on the subset of all available IP interfaces
   */
  virtual Ptr<Ipv4RoutingProtocol> Create (Ptr<Node> node) const;
  /**
   * \param name the name of the attribute to set
   * \param value the value of the attribute to set.
   *
   * This method controls the attributes of ns3::aodv::RoutingProtocol
   */
  void Set (std::string name, const AttributeValue &value);
  /**
   * Assign a fixed random variable stream number to the random variables
   * used by this model.  Return the number of streams (possibly zero) that
   * have been assigned.  The Install() method of the InternetStackHelper
   * should have previously been called by the user.
   *
   * \param stream first stream index to use
   * \param c NodeContainer of the set of nodes for which AODV
   *          should be modified to use a fixed stream
   * \return the number of stream indices assigned by this helper
   */
  int64_t AssignStreams (NodeContainer c, int64_t stream);

private:
  ObjectFactory m_agentFactory;
};

}

#endif /* AODV_HELPER_H */


top: 25px;
    margin-bottom: 15px;
}
.points___ a {
    display: block;
width: 100%;
}
.points___ a:hover {
    background: none !important;
}
.points_secton_wrap {
    display: flex;
    justify-content: flex-start;
    align-items: center;
    gap: 14px;
    width: 100%;
}
.p_number__ {
    font-size: 14px;
    font-weight: 700;
    text-align: left;
}
.text_lang_span {
    font-size: 12px;
}
.custom_menu_login_usss li {
    width: 290px;
    margin: 5px 12px;
}
.custom_menu_login_usss li > a{
   border-radius: 14px;
}
.feature_image_main::after {
    content: '';
    position: absolute;
    top: 0;
    right: 0;
    bottom: 0;
    left: 0;
    pointer-events: none;
    background: linear-gradient(360deg, #fff 0%, rgb(255 255 255 / 0%) 100%);
}
.feature_image_main::before {
    content: " ";
    background: url('../img/top_left_shadwo.png');
    height: 100%;
    background-repeat: no-repeat;
    position: absolute;
    width: 100%;
    background-attachment: fixed;
    background-size: cover;
    background-position: top left;
    top: 0;
    left: 0;
    filter: invert(1);
	opacity: 0;
}
.without_moview_div {
    width: calc(100% - 53px);
    margin-left: auto;
}
.feature_wrap {
    position: absolute;
    width: 95%;
    bottom: 18%;
	bottom: 200px;
    z-index: 111;
}
.pl_feat_vid_slider.home_feat {
	-webkit-mask-image: none;
}
.home_feat .feature_wrap {
	padding: 40px;
    background-color: rgb(255 255 255 / 20%);
    border-radius: 10px;
    width: auto;
    backdrop-filter: saturate(150%) blur(10px);
	bottom: 170px;
    top: 30px;
    display: flex;
    flex-direction: column;transition: all 0.2s;
}
.home_feat .feature_wrap:hover {
    background-color: rgb(255 255 255 / 10%);
}
.home_feat .feature_wrap h4 {
	margin: 0 0 10px;
    display: flex;
    align-items: center;
    gap: 7px;
    text-transform: uppercase;
    font-size: 14px;color: #fff;
}
.pt_new_home_feat_vidd .chanel_content > a > span, .pt_new_home_feat_vidd .feature_text_title a, .pt_new_home_feat_vidd .feature_wrap p {
    color: #fff;
}
.pt_new_home_feat_vidd.home_feat .feature_wrap p a {
    color: #ffffff !important;
}
.pt_new_home_feat_vidd .feature_channel_wrap .share_button button {
    border-color: #fff;color: #fff;
}
.pt_new_home_feat_vidd .feature_channel_wrap .share_button button:hover {
    background: #ffffff;
    color: #191919;
}
.home_feat .feature_wrap hr {
	border-color: rgb(255 255 255 / 10%);width: 100%;
}
.home_feat .feature_wrap .feature_text_title {
	font-size: 23px;
	line-height: normal;
	margin: 0 0 7px;max-height: 68px;max-width: 570px;
}
.home_feat .feature_wrap p {
	margin-top: 0;max-height:


 = matrixValues[Matrix.MSCALE_X];
            dy = matrixValues[Matrix.MTRANS_Y];
            dx = matrixValues[Matrix.MTRANS_X];
        } else {
            dx = 0;
            dy = 0;
            graphScale = 1;
        }
        canvas.translate(dx, dy);
        canvas.scale(graphScale, graphScale);

        final float dx = -this.dx;

        if (axis == null) findAxisPosition();
        xDIPx = options.getScaledDividerIntervalInPx(options.xDividerIntervalInPx, graphScale);
        yDIPx = options.getScaledDividerIntervalInPx(options.yDividerIntervalInPx, graphScale);
        xDI = options.getScaledDividerInterval(options.xDividerInterval, graphScale);
        yDI = options.getScaledDividerInterval(options.yDividerInterval, graphScale);

        float ls = options.dividerSize / 2;
        float text_ls = options.dividerSize / graphScale;
        updatePaints();

        float min_display_x = findFormulaX((dx/graphScale) - centerX) - 0.5f;
        float max_display_x = findFormulaX(((dx + getWidth())/graphScale) - centerX) + 0.5f;
        float min_display_y = findFormulaY(((-dy)/graphScale) - centerY) - 0.5f;
        float max_display_y = findFormulaY((((-dy) + getHeight())/graphScale) - centerY) + 0.5f;

        mainPoints.clear();
        if (options.drawAxisXDivider || options.drawGridXLines) {
            int xCount = (int) (centerX / xDIPx) * mdc;
            for (int i = 1; i <= xCount; i++) {
                if (min_display_x > -i*xDI || -i*xDI > max_display_x) continue;

                float xSelection = i * xDIPx;
                mainPoints.add(-i*xDI);

                if (options.drawGridXLines)
                    canvas.drawLine(centerX - xSelection, Integer.MIN_VALUE,
                            centerX - xSelection, Integer.MAX_VALUE, options.gridLinePaint);

                if (options.drawAxisXDivider)
                    canvas.drawLine(centerX - xSelection, centerY - ls,
                            centerX - xSelection, centerY + ls, options.dividerPaint);

                //if (options.drawXText)
                //    drawTextX(canvas,centerX,centerY,text_ls,-xSelection,-i);
            }

            xCount = (int) ((getGraphWidth() - centerX) / xDIPx) * mdc;
            for (int i = 1; i <= xCount; i++) {
                if (min_display_x > i*xDI  || i*xDI  > max_display_x) continue;

                float xSelection = i * xDIPx;
                mainPoints.add(i*xDI);

                if (options.drawGridXLines)
                    canvas.drawLine(centerX + xSelection, Integer.MIN_VALUE,
                            centerX + xSelection, Integer.MAX_VALUE, options.gridLinePaint);

                if (options.drawAxisXDivider)
                    canvas.drawLine(centerX + xSelection, centerY - ls,
                            centerX + xSelection, centerY + ls, options.dividerPaint);

                //if (options.drawXText)
                //   drawTextX(canvas,centerX,centerY,text_ls,xSelection,i);
            }
        }

        if (options.drawAxisYDivider || options.drawGridYLines) {
            int yCount = (int) (centerY / yDIPx) * mdc;
            for (int i = 1; i <= yCount; i++) {
                if (min_display_y > -i*yDI || -i*yDI > max_display_y) continue;

                float ySelection = i * yD


g2+g3, h0+h1+h2+h3,
            // e4+e5+e6+e7, f4+f5+f6+f7, g4+g5+g6+g7, h4+h5+h6+h7)
            tmp2 = _mm256_hadd_ps(tmp0, tmp2);
            // tmp0 = (a0+a1+a2+a3, b0+b1+b2+b3, c0+c1+c2+c3, d0+d1+d2+d3,
            // e4+e5+e6+e7, f4+f5+f6+f7, g4+g5+g6+g7, h4+h5+h6+h7)
            tmp0 = _mm256_blend_ps(tmp1, tmp2, 0b11110000);
            // tmp1 = (a4+a5+a6+a7, b4+b5+b6+b7, c4+c5+c6+c7, d4+d5+d6+d7,
            // e0+e1+e2+e3, f0+f1+f2+f3, g0+g1+g2+g3, h0+h1+h2+h3)
            tmp1 = _mm256_permute2f128_ps(tmp1, tmp2, 0x21);
            return _mm256_add_ps(tmp0, tmp1);
        }
        template <class A>
        inline batch<double, A> haddp(batch<double, A> const* row, requires_arch<avx>) noexcept
        {
            // row = (a,b,c,d)
            // tmp0 = (a0+a1, b0+b1, a2+a3, b2+b3)
            __m256d tmp0 = _mm256_hadd_pd(row[0], row[1]);
            // tmp1 = (c0+c1, d0+d1, c2+c3, d2+d3)
            __m256d tmp1 = _mm256_hadd_pd(row[2], row[3]);
            // tmp2 = (a0+a1, b0+b1, c2+c3, d2+d3)
            __m256d tmp2 = _mm256_blend_pd(tmp0, tmp1, 0b1100);
            // tmp1 = (a2+a3, b2+b3, c2+c3, d2+d3)
            tmp1 = _mm256_permute2f128_pd(tmp0, tmp1, 0x21);
            return _mm256_add_pd(tmp1, tmp2);
        }

        // insert
        template <class A, class T, size_t I, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
        inline batch<T, A> insert(batch<T, A> const& self, T val, index<I> pos, requires_arch<avx>) noexcept
        {
#if !defined(_MSC_VER) || _MSC_VER > 1900
            XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
            {
                return _mm256_insert_epi8(self, val, I);
            }
            else XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
            {
                return _mm256_insert_epi16(self, val, I);
            }
            else XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
            {
                return _mm256_insert_epi32(self, val, I);
            }
            else
            {
                return insert(self, val, pos, generic {});
            }
#endif
            return insert(self, val, pos, generic {});
        }

        // isnan
        template <class A>
        inline batch_bool<float, A> isnan(batch<float, A> const& self, requires_arch<avx>) noexcept
        {
            return _mm256_cmp_ps(self, self, _CMP_UNORD_Q);
        }
        template <class A>
        inline batch_bool<double, A> isnan(batch<double, A> const& self, requires_arch<avx>) noexcept
        {
            return _mm256_cmp_pd(self, self, _CMP_UNORD_Q);
        }

        // le
        template <class A>
        inline batch_bool<float, A>


/*********************************************************************/
/*                                                                   */
/*             Optimized BLAS libraries                              */
/*                     By Kazushige Goto <kgoto@tacc.utexas.edu>     */
/*                                                                   */
/* Copyright (c) The University of Texas, 2009. All rights reserved. */
/* UNIVERSITY EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES CONCERNING  */
/* THIS SOFTWARE AND DOCUMENTATION, INCLUDING ANY WARRANTIES OF      */
/* MERCHANTABILITY, FITNESS FOR ANY PARTICULAR PURPOSE,              */
/* NON-INFRINGEMENT AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY  */
/* THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF     */
/* TRADE. NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO   */
/* THE USE OF THE SOFTWARE OR DOCUMENTATION.                         */
/* Under no circumstances shall University be liable for incidental, */
/* special, indirect, direct or consequential damages or loss of     */
/* profits, interruption of business, or related expenses which may  */
/* arise from use of Software or Documentation, including but not    */
/* limited to those resulting from defects in Software and/or        */
/* Documentation, or loss or inaccuracy of data of any kind.         */
/*********************************************************************/

#define ASSEMBLER
#include "common.h"

#define STACK	16
#define ARGS	16

#define M	 4 + STACK + ARGS(%esp)
#define N	 8 + STACK + ARGS(%esp)
#define K	12 + STACK + ARGS(%esp)
#define ALPHA	16 + STACK + ARGS(%esp)
#define A	24 + STACK + ARGS(%esp)
#define ARG_B	28 + STACK + ARGS(%esp)
#define C	32 + STACK + ARGS(%esp)
#define ARG_LDC	36 + STACK + ARGS(%esp)
#define OFFSET	40 + STACK + ARGS(%esp)

#define J	 0 + STACK(%esp)
#define KK	 4 + STACK(%esp)
#define KKK	 8 + STACK(%esp)
#define AORIG	12 + STACK(%esp)

#if defined(PENRYN) || defined(DUNNINGTON)
#define PREFETCH     prefetcht0
#define PREFETCHSIZE  (8 * 21 + 4)
#endif

#ifdef NEHALEM
#define PREFETCH     prefetcht0
#define PREFETCHSIZE  (8 * 21 + 4)
#endif

#ifdef NANO
#define PREFETCH	prefetcht0
#define PREFETCHSIZE (8 * 2)
#endif

#define AA	%edx
#define BB	%ecx
#define LDC	%ebp
#define B	%edi
#define CO1	%esi

	PROLOGUE

	subl


f1-steps .f1-step.active .f1-step-icon {
      width: 48px;
      height: 48px;
      background: var(--theme-deafult);
      font-size: 22px;
      line-height: 20px; }
    .f1 .f1-steps .f1-step.active p {
      color: var(--theme-deafult); }
    .f1 .f1-steps .f1-step p {
      color: #898989; }
    .f1 .f1-steps .f1-step .f1-step-icon {
      display: inline-block;
      width: 40px;
      height: 40px;
      background: #898989;
      font-size: 16px;
      color: #fff;
      line-height: 20px;
      border-radius: 50%; }

.f1 .f1-buttons {
  text-align: right; }

/*Form Wizard Three ends*/
/*Form Wizard Four Start*/
.wizard-4 .action-bar {
  position: absolute;
  bottom: 50px;
  right: 50px; }

.wizard-4 .action-bar .btn {
  float: right;
  margin: 0 5px;
  background-color: #e3e0ff !important;
  border-color: #e3e0ff !important;
  color: var(--theme-deafult); }

.wizard-4 .action-bar .buttonDisabled {
  color: #59667a;
  background-color: rgba(89, 102, 122, 0.05) !important;
  border: 1px solid rgba(89, 102, 122, 0.05) !important;
  cursor: text; }

.wizard-4 .step-container {
  background: #f8f9fe; }

.wizard-4 .loader {
  display: none; }

.wizard-4 .msg-box {
  position: fixed;
  display: none;
  padding: 5px 10px;
  background-color: #e076da;
  top: 30px;
  border-radius: 5px;
  right: 60px;
  padding: 10px 20px; }
  .wizard-4 .msg-box .content {
    padding: 0;
    float: left;
    padding-top: 3px;
    color: #fff; }
  .wizard-4 .msg-box .close {
    color: #fff;
    margin-left: 10px;
    opacity: 1;
    font-size: 18px;
    line-height: 1.4; }

.wizard-4 ul.anchor {
  float: left;
  width: 30%;
  height: 100vh;
  padding: 80px; }
  .wizard-4 ul.anchor .disabled {
    opacity: 0.7;
    color: #59667a; }
    .wizard-4 ul.anchor .disabled h4 {
      background-color: rgba(89, 102, 122, 0.15); }
  .wizard-4 ul.anchor .logo {
    padding-bottom: 20px; }
  .wizard-4 ul.anchor li {
    position: relative;
    display: block;
    margin: 0;
    padding: 0;
    padding-bottom: 19px;
    float: left;
    clear: both;
    width: 100%;
    -webkit-box-sizing: border-box;
            box-sizing: border-box;
    z-index: 0; }
    .wizard-4 ul.anchor li + li a {
      padding-left: 80px; }
    .wizard-4 ul.anchor li:last-child {
      position: absolute;
      bottom: 0; }
      .wizard-4 ul.anchor li:last-child img {
        height: 300px; }
    .wizard-4 ul.anchor li h4 {
      display: inline-block;
      background-color: rgba(214, 77, 207, 0.2);
      padding: 16px 23px;
      border-radius: 100%;
      position: absolute;
      left: 0;
      top: 6px; }
    .wizard-4 ul.anchor li a {
      display: block;
      position: relative;
      float: left;
      margin: 0;
      padding: 10px 2


 UTF-8 string with no convention defined for its
/// contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11
/// output via :1'.
///
/// The description event is sent after creating an xdg_output (see
/// xdg_output_manager.get_xdg_output) and whenever the description
/// changes. The description is optional, and may not be sent at all.
///
/// For objects of version 2 and lower, this event is only sent once per
/// xdg_output, and the description does not change over the lifetime of
/// the wl_output global.
///
/// This event is deprecated, instead clients should use
/// wl_output.description. Compositors must still support this event.
///
/// Event handler for Description
/// - [description]: output description
 void onDescription(ZxdgOutputV1DescriptionEventHandler handler) {
   _descriptionHandler = handler;
 }

 ZxdgOutputV1DescriptionEventHandler? _descriptionHandler;

 @override
 void dispatch(int opcode, int fd, Uint8List data) {
logLn("ZxdgOutputV1.dispatch($opcode, $fd, $data)");
   switch (opcode) {     case 0:

       if (_logicalPositionHandler != null) {
var offset = 0;
final x = ByteData.view(data.buffer).getInt32(offset, Endian.little);
offset += 4;
final y = ByteData.view(data.buffer).getInt32(offset, Endian.little);
offset += 4;
var event = ZxdgOutputV1LogicalPositionEvent(
x,
y,
        );
         _logicalPositionHandler!(event);
       }
       break;
     case 1:

       if (_logicalSizeHandler != null) {
var offset = 0;
final width = ByteData.view(data.buffer).getInt32(offset, Endian.little);
offset += 4;
final height = ByteData.view(data.buffer).getInt32(offset, Endian.little);
offset += 4;
var event = ZxdgOutputV1LogicalSizeEvent(
width,
height,
        );
         _logicalSizeHandler!(event);
       }
       break;
     case 2:

       if (_doneHandler != null) {
         _doneHandler!(ZxdgOutputV1DoneEvent());
       }
       break;
     case 3:

       if (_nameHandler != null) {
var offset = 0;
final nameLength = ByteData.view(data.buffer).getUint32(offset, Endian.little);
offset += 4;
final name = utf8.decode(data.sublist(offset, offset + nameLength - 1));
offset += nameLength; // Skip the string bytes and null terminator
while (offset % 4 != 0) { offset++; } // Padding
var event = ZxdgOutputV1NameEvent(
name,
        );
         _nameHandler!(event);
       }
       break;
     case 4:

       if (_descriptionHandler != null) {
var offset = 0;
final descriptionLength = ByteData.view(data.buffer).getUint32(offset, Endian.little);
offset += 4;
final description = utf8.decode(data.sublist(offset, offset + descriptionLength - 1));
offset += descriptionLength; // Skip the string bytes and null terminator
while (offset % 4 != 0) { offset++; } // Padding
var event = ZxdgOutputV1DescriptionEvent(
description,
        );
         _descriptionHandler!(event);
       }
       break;
   }
 }
}

// Generated by dart-wayland-scanner
// https://github.com/your-repo/dart-wayland-scanner
// XML file : https://gitlab.freedesktop.org/wayland/wayland-protocols/-/raw/main/unstable/idle-inhibit/idle-inhibit-unstable-v1.xml
//
// idle_inhibit_unstable_v1 Protocol Copyright:
///
/// Copyright © 2015 Samsung Electronics Co., Ltd
///
/// Permission is hereby granted, free of charge, to any person obtaining a
/// copy of this software and associated documentation files (the "Software"),
/// to deal in the Software without restriction, including without limitation
/// the rights to use, copy, modify, merge, publish, distribute, sublicense,
/// and/or sell co


EXP  = 128
	REM  = 75
	EXP2 = 64
)

func TestGrowing(t *testing.T) {
	h := New()

	if len(h.bkts) != _BSZ {
		t.Fatalf("Initial bucket size is wrong: %d vs %d\n", len(h.bkts), _BSZ)
	}
	// Create _INBOX style end tokens
	var toks [INS][]byte
	for i, _ := range toks {
		u := make([]byte, 13)
		io.ReadFull(rand.Reader, u)
		toks[i] = []byte(hex.EncodeToString(u))
		h.Set(toks[i], toks[i])
		tg := h.Get(toks[i]).([]byte)
		if !bytes.Equal(tg, toks[i]) {
			t.Fatalf("Did not match properly, '%s' vs '%s'\n", tg, toks[i])
		}
	}
	if len(h.bkts) != EXP {
		t.Fatalf("Expanded bucket size is wrong: %d vs %d\n", len(h.bkts), EXP)
	}
}

func TestHashMapCollisions(t *testing.T) {
	h := New()
	h.rsz = false

	// Create _INBOX style end tokens
	var toks [INS][]byte
	for i, _ := range toks {
		u := make([]byte, 13)
		io.ReadFull(rand.Reader, u)
		toks[i] = []byte(hex.EncodeToString(u))
		h.Set(toks[i], toks[i])
		tg := h.Get(toks[i]).([]byte)
		if !bytes.Equal(tg, toks[i]) {
			t.Fatalf("Did not match properly, '%s' vs '%s'\n", tg, toks[i])
		}
	}
	if len(h.bkts) != _BSZ {
		t.Fatalf("Bucket size is wrong: %d vs %d\n", len(h.bkts), _BSZ)
	}
	h.grow()
	if len(h.bkts) != 2*_BSZ {
		t.Fatalf("Bucket size is wrong: %d vs %d\n", len(h.bkts), 2*_BSZ)
	}
	ti := 32
	tg := h.Get(toks[ti]).([]byte)
	if !bytes.Equal(tg, toks[ti]) {
		t.Fatalf("Did not match properly, '%s' vs '%s'\n", tg, toks[ti])
	}

	h.Remove(toks[99])
	rg := h.Get(toks[99])
	if rg != nil {
		t.Fatalf("After remove should have been nil! '%s'\n", rg.([]byte))
	}
}

func TestAll(t *testing.T) {
	h := New()
	h.Set([]byte("1"), 1)
	h.Set([]byte("2"), 1)
	h.Set([]byte("3"), 1)
	all := h.All()
	if len(all) != 3 {
		t.Fatalf("Expected All() to return 3, but got %d\n", len(all))
	}
	allkeys := h.AllKeys()
	if len(allkeys) != 3 {
		t.Fatalf("Expected All() to return 3, but got %d\n", len(allkeys))
	}
}

func TestSetDoesReplaceOnExisting(t *testing.T) {
	h := New()
	k := []byte("key")
	h.Set(k, "foo")
	h.Set(k, "bar")
	all := h.All()
	if len(all) != 1 {
		t.Fatalf("Set should replace, expected 1 vs %d\n", len(all))
	}
	s, ok := all[0].(string)
	if !ok {
		t.Fatalf("Value is incorrect: %v\n", all[0].(string))
	}
	if s != "bar" {
		t.Fatalf("Value is incorrect, expected 'bar' vs '%s'\n", s)
	}
}

func Test


// Represent bytes in hexadecimal
///
/// If a [separator] is provided, it is placed the hexadecimal characters
/// representing each byte. Otherwise, all the hexadecimal characters are
/// simply concatenated together.

String bin2hex(Uint8List bytes, {String? separator, int? wrap}) {
  var len = 0;
  final buf = StringBuffer();
  for (final b in bytes) {
    final s = b.toRadixString(16);
    if (buf.isNotEmpty && separator != null) {
      buf.write(separator);
      len += separator.length;
    }

    if (wrap != null && wrap < len + 2) {
      buf.write('\n');
      len = 0;
    }

    buf.write('${(s.length == 1) ? '0' : ''}$s');
    len += 2;
  }
  return buf.toString();
}
//----------------------------------------------------------------

void main(List<String> args) {
  if (args.contains('-h') || args.contains('--help')) {
    print('Usage: digest-demo');
    return;
  }

  // Calculate digest with complete data
  //
  // Note: the progressive example is hardcoded to produce the digest of
  // 'Hello world!', so there is no point in changing the 'data' if you want
  // to see they both produce the same result.

  const dataForComplete = 'Hello world!';

  print('SHA-256 digest of "$dataForComplete":');
  final hash1 =
      completeExample(Uint8List.fromList(utf8.encode(dataForComplete)));
  print('   with complete data: ${bin2hex(hash1)}');

  // Calculate digest by providing the data progressively

  final hash2 = progressiveExample();
  print('with progressive data: ${bin2hex(hash1)}');

  // Prove they both produce the same digest value

  for (var x = 0; x < hash1.length; x++) {
    if (hash1[x] != hash2[x]) {
      print('Error: hashes are different');
    }
  }

  // Other examples

  resetExample();

  binaryExample();
}
import 'dart:math';
import 'dart:ui' as ui;

import 'package:vector_math/vector_math.dart';

abstract class Camera {
  Vector3 get position;
  Matrix4 getViewTransform(ui.Size dimensions);
}

Matrix4 _matrix4LookAt(Vector3 position, Vector3 target, Vector3 up) {
  Vector3 forward = (target - position).normalized();
  Vector3 right = up.cross(forward).normalized();
  up = forward.cross(right).normalized();

  return Matrix4(
    right.x,
    up.x,
    forward.x,
    0.0, //
    right.y,
    up.y,
    forward.y,
    0.0, //
    right.z,
    up.z,
    forward.z,
    0.0, //
    -right.dot(position),
    -up.dot(position),
    -forward.dot(position),
    1.0, //
  );
}

Matrix4 _matrix4Perspective(
  double fovRadiansY,
  double aspectRatio,
  double zNear,
  double zFar,
) {
  double height = tan(fovRadiansY * 0.5);
  double width = height * aspectRatio;

  return Matrix4(
    1.0 / width,
    0.0,
    0.0,
    0.0,
    0.0,
    1.0 / height,
    0.0,
    0.0,
    0.0,
    0.0,
    zFar / (zFar - zNear),
    1.0,
    0.0,
    0.0,
    -(zFar * zNear) / (zFar - zNear),
    0.0,
  );
}


        const kMaxStreamId = StreamHandler.MAX_STREAM_ID;
        for (var i = 1; i <= kMaxStreamId; i += 2) {
          var stream = client.makeRequest(headers, endStream: true);
          var messages = await stream.incomingMessages.toList();
          expect(messages, hasLength(1));
        }

        expect(client.isOpen, false);
        expect(
          () => client.makeRequest(headers),
          throwsA(const TypeMatcher<StateError>()),
        );

        await Future<void>.delayed(const Duration(seconds: 1));
        await client.finish();
      }

      var serverFuture = serverFun();
      var clientFuture = clientFun();

      await serverFuture;
      await clientFuture;
    });
  });
}
// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:js_interop';

import '../locale/locale.dart';
import 'list_format_impl.dart';
import 'list_format_options.dart';

ListFormatImpl getListFormatterECMA(Locale locale, ListFormatOptions options) =>
    _ListFormatECMA.tryToBuild(locale, options);

@JS('Intl.ListFormat')
extension type ListFormat._(JSObject _) implements JSObject {
  external factory ListFormat([JSArray<JSString> locale, JSAny options]);
  external String format(JSArray<JSString> list);

  external static JSArray<JSString> supportedLocalesOf(
    JSArray<JSString> locales, [
    JSAny options,
  ]);
}

class _ListFormatECMA extends ListFormatImpl {
  _ListFormatECMA(super.locale, super.options);

  static ListFormatImpl tryToBuild(Locale locale, ListFormatOptions options) {
    final supportedLocales = supportedLocalesOf(locale);
    return _ListFormatECMA(
      supportedLocales.firstOrNull ?? Locale.parse('und'),
      options,
    );
  }

  static List<Locale> supportedLocalesOf(Locale locale) {
    return ListFormat.supportedLocalesOf(
      [locale.toLanguageTag().toJS].toJS,
    ).toDart.whereType<String>().map(Locale.parse).toList();
  }

  @override
  String formatImpl(List<String> list) {
    return ListFormat(
      [locale.toLanguageTag().toJS].toJS,
      options.toJsOptions(),
    ).format(list.map((e) => e.toJS).toList().toJS);
  }
}

extension on ListFormatOptions {
  JSAny toJsOptions() => {'type': type.jsName, 'style': style.name}.jsify()!;
}
// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

/// This library provides an http/2 interface on top of a bidirectional stream
/// of bytes.
///
/// The client and server sides can be created via [ClientTransportStream] and
/// [ServerTransportStream] respectively. Both sides can be configured via
/// settings (see [ClientSettings] and [ServerSettings]). The settings will be
/// communicated to the remote peer (if necessary) and will be valid during the
/// entire lifetime of the connection.
///
/// A http/2 transport allows a client to open a bidirectional stream (see
/// [ClientTransportConnection.makeRequest]) and a server can open (or push) a
/// unidirectional stream to the client via [ServerTransportStream.push].
///
/// In both cases (unidirectional and bidirectional stream), one can send
/// headers and data to the other side (via [HeadersStreamMessage] and
/// [DataStreamMessage]). These messages are ordered and will arrive in the same
/// order as they were sent (data mes


指纹规则库失败: %v\n", err)
		os.Exit(1)
	}

	// 读取目标文件
	targets, err := readTargetsFromFile(targetsFile)
	if err != nil {
		fmt.Printf("读取目标文件失败: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("从文件中读取到 %d 个目标\n", len(targets))
	fmt.Println("开始并发扫描...")

	// 使用并发执行扫描
	results := scanTargetsWithConcurrency(targets, proxy, timeout, workerCount)

	// 输出结果
	fmt.Println("\n扫描结果:")
	fmt.Printf("总共扫描: %d 个目标, 成功: %d 个\n",
		len(targets), len(results))

	// 输出每个目标的扫描结果
	fmt.Println("\n详细结果:")
	for target, result := range results {
		fmt.Printf("\n目标: %s\n", target)
		fmt.Printf("  - 状态码: %d\n", result.StatusCode)
		fmt.Printf("  - 标题: %s\n", result.Title)
		if result.Server != nil {
			fmt.Printf("  - 服务器: %s\n", result.Server.ServerType)
		}

		// 输出匹配的指纹
		matches := gxx.GetFingerMatches(result)
		if len(matches) > 0 {
			fmt.Printf("  - 匹配指纹: %d 个\n", len(matches))
			for i, match := range matches[:min(3, len(matches))] {
				fmt.Printf("    %d. %s\n", i+1, match.Finger.Info.Name)
			}
			if len(matches) > 3 {
				fmt.Printf("    ...（还有 %d 个）\n", len(matches)-3)
			}
		} else {
			fmt.Printf("  - 匹配指纹: 无\n")
		}
	}

	// 将结果保存到文件
	outputFile := filepath.Join(exampleDir, "scan_results.txt")
	if err := saveResultsToFile(outputFile, results); err != nil {
		fmt.Printf("保存结果失败: %v\n", err)
	} else {
		fmt.Printf("\n结果已保存到: %s\n", outputFile)
	}

	fmt.Println("--------------------------------------------")
	fmt.Printf("总耗时: %s\n", time.Since(startTime))
	fmt.Println("扫描完成")
}

// createExampleTargetFile 创建示例目标文件
func createExampleTargetFile(filePath string) {
	// 检查文件是否已存在
	if _, err := os.Stat(filePath); err == nil {
		fmt.Println("目标文件已存在:", filePath)
		return
	}

	// 创建示例目标
	targets := []string{
		"example.com",
		"github.com",
		"httpbin.org",
	}

	// 创建文件
	file, err := os.Create(filePath)
	if err != nil {
		fmt.Printf("创建目标文件失败: %v\n", err)
		os.Exit(1)
	}
	defer file.Close()

	// 写入目标
	for _, target := range targets {
		file.WriteString(target + "\n")
	}

	fmt.Println("已创建示例目标文件:", filePath)
	fmt.Println("包含以下目标:")
	for _, target := range targets {
		fmt.Println("  -", target)
	}
}

// readTargetsFromFile 从文件中读取目标列表
func readTargetsFromFile(filePath string