sitional//en">

<title>The Abominations of Yondo 译者：Fhtagn</title>
<meta name="generator" content="winchm">
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<link rel="stylesheet" type="text/css" href="d:\coc不全书\coc7thchm\style.css">

The Abominations of Yondo 译者：Fhtagn

雍毒（Yondo）荒漠的沙有别于其他荒漠，这是因为雍毒地正是距世界边缘最近的地域，猛烈怪异的飓风自星象家们无从目睹的深渊席卷而来，在这片荒漠播撒着来自朽坏行星的灰色尘埃与暗淡的太阳们挥散出的黑色灰烬。起伏不平，遍布坑洼的荒原上，矗立着半圆形的黑暗群山，这些山并非全是自然形成的，其中有一些是深陷在沙地中的巨大陨石。那些幽冥地府中的怪物――在文明开化的土地上被众神所驱逐――却在这里四处伏行。因为在雍毒地没有众神，这里只有来自业已消失的星球的苍老妖灵，与那些在古老地狱的大毁灭中幸存的无根恶魔。

春日里的某个中午，我被那些昂格（Ong）的审判官丢在这片无边无际的仙人掌丛林中自生自灭，这便是我的雍毒地之旅的不祥开端。我再说一遍，那是春日里的某个中午，然而在这片奇诡的丛林中，我却找不到一丝春季的气息，甚至连对于春天的记忆也无从想起。我在丛林中艰难前行，拨开那些垂死的半腐烂植物，它们灰褐色的肿胀外形不似任何一种仙人掌，却呈现着一种难以形容的可憎形状。凝滞的空气中充斥着粘稠的腐臭气息，苔藓如癞疮一般星点遍布于黑色土壤和疯长的黄褐色植物之上。灰绿色的的毒蛇从干枯瓦解的仙人掌枝干中昂起头来，用没有瞳孔和眼睑，闪闪发光的赭色眼睛对我虎视眈眈。这些诡异事物在之前几个小时中始终令我心中惴惴


w  	#$200,d0
  bmi.s	.alpha_ok
  sub.w  	#$200,d0
.alpha_ok:
  move.w	d0,atari_alpha
  move.w	atari_beta,d1
  addq.w	#$1,d1
  cmpi.w  	#$200,d1
  bmi.s	.beta_ok
  sub.w  	#$200,d1
.beta_ok:
  move.w	d1,atari_beta

.rotate_points:		; Calculate the new coords.
  move.l	#atari_dots,a0	; Adress of initial coords.
  move.l	#new_coords,a1	; ... final ...
  move.w	#$40,a2	; z translation is 0.
  move.w	atari_dots_nb,d2
  jsr	rotate

.draw_lines:		; Now let's draw the lines.
  move.w	atari_lines_nb,d4
  move.l	#atari_lines,a5
  move.l	#new_coords,a4
  move.w	#$9f,d5	; For x centering.
  move.w	#$63,d6	; For y centering.
  subq.w	#$1,d4	; Cos of the dbra.
.one_line:
  move.w	(a5)+,d1	; Index of initial point.
  move.w	(a5)+,d3	; ... final ...
  subq.w	#$1,d1	; We want the position, not the index.
  subq.w	#$1,d3
  add.w	d1,d1	; 4 bytes per point.
  add.w	d1,d1
  add.w	d3,d3
  add.w	d3,d3
  move.w	(a4,d1.w),d0	; x1.
  move.w	$2(a4,d1.w),d1	; y1.
  move.w	(a4,d3.w),d2	; x2.
  move.w	$2(a4,d3.w),d3	; y2.
  add.w	d5,d0	; Re center the points.
  add.w	d6,d1
  add.w	d5,d2
  add.w	d6,d3
  move.l	a6,a0	; Ramvideo adress.
  jsr	fastline
  dbra	d4,.one_line

  dbra	d7,atari_screen1

wait_a_while:		; Immediatly fading is not nice.
  moveq.l	#$1f,d7	; Wait more than one second.
.wait:
  stop	#$2300
  dbra	d7,.wait

end_2nd_part:		; 2nd part over, clear the screens.
  moveq.l	#$7,d2	; Let's make a nice fade to black.
.fade_black:
  move.l	#atari_colors,a0; Initial colors
  move.l	#$ff8240,a1
  move.w	d2,d0	; Fading index.
  moveq.l	#$1,d1	; Change all colors.
  jsr	fading

  rept	3  	; Wait the Vbl 3 times.
  stop	#$2300
  endr

  subq.l	#$1,d2	; Decrement the fade.
  cmpi.l	#$0,d2	; Minimum fade already done?
  bpl.s	.fade_black

  move.l	screen1_ad,a0	; Clear the screens.
  jsr	cls
  move.l	screen2_ad,a0
  jsr	cls

.wait


|cRXP_WARN_as it's difficult but doable. She has a 130 damage shield on a 15s cooldown, and 110 damage instant shock ability|r << Mage/Warlock
    .complete 447,2 --Skittering Blood (6)
    .mob Moss Stalker
    .unitscan Krethis Shadowspi
step
    #loop
    .goto Silverpine Forest,41.60,21.65,0
    .goto Silverpine Forest,41.37,19.64,50,0
    .goto Silverpine Forest,41.60,21.65,50,0
    .goto Silverpine Forest,42.36,23.77,50,0
    .goto Silverpine Forest,44.67,24.84,50,0
    .goto Silverpine Forest,46.08,26.62,50,0
    >>Finish killing |cRXP_ENEMY_Bears|r. Loot them for their |cRXP_LOOT_Hearts|r
    .complete 447,1 --Grizzled Bear Heart (6)
    .mob Ferocious Grizzled Bear
    .mob Giant Grizzled Bear
    .unitscan Old VIcejaw
    .unitscan Son of Arugal
step
    #softcore
    #completewith ArugalTurnin
    .deathskip >> Die and respawn at the |cRXP_FRIENDLY_Spirit Healer|r
step
    #hardcore
    #completewith next
    .goto Silverpine Forest,45.51,41.26,100,0
    .subzone 228 >>Travel back to The Sepulcher
step
    #xprate <1.5
    .goto Silverpine Forest,44.20,39.73
    >>|Tinterface/worldmap/chatbubble_64grey.blp:20|tTalk to |cRXP_FRIENDLY_Dalar|r
    .turnin 422 >> Turn in Arugal's Folly
    .accept 423 >> Accept Arugal's Folly
    .target Dalar Dawnweaver
step
    #xprate >1.49
    .goto Silverpine Forest,44.20,39.73
    >>|Tinterface/worldmap/chatbubble_64grey.blp:20|tTalk to |cRXP_FRIENDLY_Dalar|r
    .turnin 422 >> Turn in Arugal's Folly
    .target Dalar Dawnweaver
step
    #optional
    #label ArugalTurnin
step
    #completewith next
    .goto Silverpine Forest,43.09,41.33,8,0
    .goto Silverpine Forest,42.75,41.30,8,0
    .goto Silverpine Forest,42.76,40.90,8,0
    .goto Silverpine Forest,43.43,40.87,2 >> Enter the crypt
step
    .goto Silverpine Forest,43.43,40.87
    >>|Tinterface/worldmap/chatbubble_64grey.blp:20|tTalk to |cRXP_FRIENDLY_Hadrec|r in the crypt
    .turnin 437 >> Turn in The Dead Fields
    .accept 438 >> Accept The Decrepit Ferry
    .target High Executor Hadrec
step << !Mage !Priest
    .goto Silverpine Forest,44.05,39.78
    >>|Tinterface/worldmap/chatbubble_64grey.blp:20|tTalk to |cRXP_FRIENDLY_Gwyn|r
    >>|cRXP_BUY_Buy|r |T134532:0|t[Red-speckled Mushrooms] |cRXP_BUY_from her|r
    .vendor >> Vendor trash
    .collect 4605,20,423,1 --Red-speckled Mushroom (20)
    .target Gwyn Farrow
step
    .goto Silverpine Forest,43.98,39.89
    >>|Tinterface/worldma


groups using custom filtering functions
# - group_a_filter / group_b_filter: functions that return a boolean mask for filtering
# - label_a / label_b: what names to assign to filtered groups
# - Note: Even though you can assign custom labels like 'young' and 'adult',
# these are still internally treated as Group A and Group B respectively.
# All subsequent tests and summaries will treat 'young' as Group A and 'adult' as Group B
# based on the label_a and label_b values you define here.
ab.assign_groups(
    group_a_filter=lambda df: df['age'] < 30,
    group_b_filter=lambda df: df['age'] >= 30,
    label_a='young',
    label_b='adult'
)

# Method 3: Load groups from two separate files (CSV or Excel)
# - filepath_a / filepath_b: paths to files containing each group
# - col_name: column to analyze
# - label_a / label_b: labels for each group
# - Note: Each file is assumed to represent a single group entirely.
#   All rows in `filepath_a` are labeled as `label_a`, and all rows in `filepath_b` are labeled as `label_b`.
#   The input files do not need to contain a column for group membership.
#   However, both files must have the same column names and the same structure,
#   especially for the column specified in `col_name`, otherwise an error will occur.
ab.assign_groups_from_files(
    filepath_a='group_a.csv',
    filepath_b='group_b.csv',
    col_name='purchase_amount',
    file_type='csv',
    label_a='A',
    label_b='B'
)
```

### Step 3 – Run the Test

```python
# Run significance test
ab.is_ab_test_significant()
```

# PythonProject1_Nguy-n-Minh-Tu-n-Ki-t_B23DCCE060# Crypto Hornet Listings Bot — MVP

Бот автоматично **збирає повідомлення про лістинги** з вказаних Telegram‑каналів (user‑клієнтом через MTProto/Telethon), **парсить** їх у події та **публікує зведення** у ваш канал від імені *Telegram‑бота* (Bot API).

> ⚠ Для читання інших каналів потрібен **user client** (ваш особистий акаунт, API ID/Hash з my.telegram.org). Сам бот (BotFather‑token) не може читати чужі канали — лише публікувати. Тому тут **два** токени: user‑session (Telethon) + bot‑token.

## Що вміє MVP
- Слухає задані канали (див. `sources.yml`), фільтрує нові повідомлення.
- Витягує з тексту біржу, тип (spot/futures/alpha), пару/токен, час відкриття, мережу, контракт.
- Формує **зведене повідомлення у стилі ск


n { Person(instance(tag = "name")) }
            onReady {
                assertEquals("Salomon", instance<Person>().name)
                passed = true
            }
        }
        assertTrue(passed)
    }

}
package org.kodein.di

import org.kodein.type.TypeToken
import org.kodein.type.erasedOf
import kotlin.reflect.KProperty

/**
 * A trigger is used to force retrieval at a given time rather than at first property access.
 *
 * 1. Set a trigger to [DIAware.diTrigger].
 * 2. When you want retrieval to happen, call [trigger].
 */
@Suppress("unused")
public class DITrigger {

    /**
     * All properties that will be retrieved when the trigger happens.
     */
    public val properties: MutableList<Lazy<*>> = ArrayList()

    /**
     * Trigger retrieval of all properties that are registered in [properties].
     */
    public fun trigger(): Unit = properties.forEach { it.value }

}

public interface LazyDelegate<out V> {
    /** @suppress */
    public operator fun provideDelegate(receiver: Any?, prop: KProperty<Any?>): Lazy<V>
}

/**
 * A property delegate provider for DI retrieval.
 * Provides a `Lazy` value that, when accessed, retrieve the value from DI.
 *
 * In essence, the DI object is accessed only upon retrieving.
 */
@Deprecated(
    message = "This is an internal API, use LazyDelegate instead.",
    replaceWith = ReplaceWith("LazyDelegate<V>"),
) // TODO set as internal
public class DIProperty<out V>(
    internal val trigger: DITrigger?,
    public val originalContext: DIContext<*>,
    private val get: (DIContext<*>, String) -> V,
) : LazyDelegate<V> {

    override fun provideDelegate(receiver: Any?, prop: KProperty<Any?>): Lazy<V> = lazy {
        @Suppress("UNCHECKED_CAST")
        val context = if (receiver != null && originalContext === AnyDIContext) {
            DIContext(erasedOf(receiver) as TypeToken<in Any>, receiver)
        } else {
            originalContext
        }

        get(context, prop.name)
    }.also { trigger?.properties?.add(it) }
}

@Suppress("DEPRECATION")
public class DIPropertyMap<in I, out O>(
    private val base: DIProperty<I>,
    private val map: (I) -> O,
) : LazyDelegate<O> {

    override fun provideDelegate(receiver: Any?, prop: KProperty<Any?>): Lazy<O> = lazy {
        map(base.provideDelegate(receiver, prop).value)
    }.also {
        base.trigger?.properties?.add(it)
    }

}package org.kodein.di

import org.kodein.di.bindings.NoArgBindingDI
import org.kodein.di.bindings.Provider
import org.kodein.type.generic

/**
 * Creates a factory: each time an instance is needed, the function [creator] function will be called.
 *
 * T generics will be erased!
 *
 * A provider is like a [factory], but without argument.
 *
 * @param T The created type.
 * @param creator The function that will be called each time an instance is requested. Should create a new instance.
 * @return A provider ready to be bound.
 */
public inline fun <C : Any, reified T : Any> DI.BindBuilder<C>.provider(
    noinline creator: NoArgBindingDI<C>.() -> T,
): Provider<C, T> = Provider(contextType, generic(), creator)

/**
 * Creates a factory: each time an instance is needed, the function [creator] function will be called.
 *
 * T generics will be erased!
 *
 * A provider is like a [factory], but without argument.
 *
 * @param T The created type.
 * @param creator The


x[word] for word in target_text.split()]
    decoder_target_seq = [target_token_index[word] for word in target_text.split()]

    encoder_input_data.append(encoder_input_seq)
    decoder_input_data.append(decoder_input_seq)
    decoder_target_data.append(decoder_target_seq)

# Appliquer le padding pour uniformiser les séquences
max_encoder_seq_length = max(len(seq) for seq in encoder_input_data)
max_decoder_seq_length = max(len(seq) for seq in decoder_input_data)

encoder_input_data = pad_sequences(encoder_input_data, maxlen=max_encoder_seq_length, padding='post')
decoder_input_data = pad_sequences(decoder_input_data, maxlen=max_decoder_seq_length, padding='post')
decoder_target_data = pad_sequences(decoder_target_data, maxlen=max_decoder_seq_length, padding='post')

# Construire le modèle Seq2Seq
def build_seq2seq_model(vocab_size, embedding_dim, max_length):
    # Définir l'encodeur
    encoder_inputs = Input(shape=(None,))
    enc_emb = Embedding(vocab_size, embedding_dim)(encoder_inputs)
    encoder_lstm = LSTM(256, return_state=True)
    encoder_outputs, state_h, state_c = encoder_lstm(enc_emb)
    encoder_states = [state_h, state_c]

    # Définir le décodeur
    decoder_inputs = Input(shape=(None,))
    dec_emb_layer = Embedding(vocab_size, embedding_dim)
    dec_emb = dec_emb_layer(decoder_inputs)
    decoder_lstm = LSTM(256, return_sequences=True, return_state=True)
    decoder_outputs, _, _ = decoder_lstm(dec_emb, initial_state=encoder_states)
    decoder_dense = Dense(vocab_size, activation='softmax')
    decoder_outputs = decoder_dense(decoder_outputs)

    # Créer le modèle
    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
    model.compile(optimizer=Adam(learning_rate=0.0002, beta_1=0.5), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
    return model

# Initialiser le modèle
model = build_seq2seq_model(vocab_size, embedding_dim, max_length)

# Afficher un résumé du modèle
print("Seq2Seq Model:")
model.summary()

# Entraîner le modèle avec une stratégie d'arrêt anticipé
from tensorflow.keras.callbacks import EarlyStopping

early_stopping = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True)

model.fit([encoder_input_data, decoder_input_data], decoder_target_data,
          batch_size=batch_size,
          epochs=epochs,
          validation_split=0.2,
          steps_per_epoch=1000,  # Limiter les étapes par époque
          callbacks=[early_stopping])

# Sauvegarder le modèle entraîné
model.save('seq2seq_model.keras')

# Sauvegarder le tokenizer pour une réutilisation future
with open('tokenizer.pickle', 'wb') as handle:
    pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)


else
						{
							Data.Blocks[i].Fog.TrackPosition = StartingDistance + Data.BlockInterval;
							CurrentRoute.Tracks[0].Elements[n].Events.Add(new FogChangeEvent(CurrentRoute, 0.0, PreviousFog, CurrentFog, Data.Blocks[i].Fog));
							PreviousFog = CurrentFog;
							CurrentFog = Data.Blocks[i].Fog;
						}
					}
				}
				// rail sounds
				if (!PreviewOnly)
				{
					int j = Data.Blocks[i].RailType[0];
					int r = j < Data.Structure.Run.Length ? Data.Structure.Run[j] : 0;
					int f = j < Data.Structure.Flange.Length ? Data.Structure.Flange[j] : 0;
					if (CurrentRunIndex != r || CurrentFlangeIndex != f)
					{
						CurrentRoute.Tracks[0].Elements[n].Events.Add(new RailSoundsChangeEvent(0.0, CurrentRunIndex, CurrentFlangeIndex, r, f));
					}

					CurrentRunIndex = r;
					CurrentFlangeIndex = f;
				}
				// point sound
				if (!PreviewOnly)
				{
					if (i < Data.Blocks.Count - 1)
					{
						for (int jj = 0; jj < Data.Blocks[i].Rails.Count; jj++)
						{
							int j = Data.Blocks[i].Rails.ElementAt(jj).Key;
							if (Data.Blocks[i].Rails[j].RailStarted && Data.Blocks[i + 1].Rails.ContainsKey(j))
							{
								bool q = false;
								for (int kk = 0; kk < Data.Blocks[i].Rails.Count; kk++)
								{
									int k = Data.Blocks[i].Rails.ElementAt(kk).Key;
									if (Data.Blocks[i].Rails[k].RailStarted && Data.Blocks[i + 1].Rails.ContainsKey(k))
									{
										bool qx = Math.Sign(Data.Blocks[i].Rails[k].RailStart.X - Data.Blocks[i].Rails[j].RailStart.X) != Math.Sign(Data.Blocks[i + 1].Rails[k].RailEnd.X - Data.Blocks[i + 1].Rails[j].RailEnd.X);
										bool qy = (Data.Blocks[i].Rails[k].RailStart.Y - Data.Blocks[i].Rails[j].RailStart.Y) * (Data.Blocks[i + 1].Rails[k].RailEnd.Y - Data.Blocks[i + 1].Rails[j].RailEnd.Y) <= 0.0;
										if (qx && qy)
										{
											q = true;
											break;
										}
									}
								}
								if (q)
								{
									bool addPointSound = true;
									if (Data.Blocks[i].Switches != null)
									{
										for (int sw = 0; sw < Data.Blocks[i].Switches.Length; sw++)
										{
											if (Data.Blocks[i].Switches[sw] != null)
											{
												if (sw == j || Data.Blocks[i].Switches[sw].SecondTrack == j)
												{
													/*
													 * Switches are obviously(?) going to be on intersecting tracks
													 * This means that we don't want to add the default point sound when Rail0 intersects with
													 * another, but should do it in the switch instead for consistancy
													 *
													 * Longer term, the original point sound method should really be got rid of entirely
													 * (Parser option??)
													 */
													addPointSound = false;
													break;
												}

											}
										}
									}
									if (addPointSound)
									{
										CurrentRoute.Tracks[j].Elements[n].Events.Add(new PointSoundEvent());
									}

								}
							}
						}
					}
				}
				// st


SFS_PATH_MAX, "%lu", target_frequency);

	return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_SET_SPEED,
					     freq, strlen(freq));
}

struct cpufreq_stats *cpufreq_get_stats(unsigned int cpu,
					unsigned long long *total_time)
{
	struct cpufreq_stats *first = NULL;
	struct cpufreq_stats *current = NULL;
	char one_value[SYSFS_PATH_MAX];
	char linebuf[MAX_LINE_LEN];
	unsigned int pos, i;
	unsigned int len;

	len = sysfs_cpufreq_read_file(cpu, "stats/time_in_state",
				linebuf, sizeof(linebuf));
	if (len == 0)
		return NULL;

	*total_time = 0;
	pos = 0;
	for (i = 0; i < len; i++) {
		if (i == strlen(linebuf) || linebuf[i] == '\n')	{
			if (i - pos < 2)
				continue;
			if ((i - pos) >= SYSFS_PATH_MAX)
				goto error_out;
			if (current) {
				current->next = malloc(sizeof(*current));
				if (!current->next)
					goto error_out;
				current = current->next;
			} else {
				first = malloc(sizeof(*first));
				if (!first)
					goto error_out;
				current = first;
			}
			current->first = first;
			current->next = NULL;

			memcpy(one_value, linebuf + pos, i - pos);
			one_value[i - pos] = '\0';
			if (sscanf(one_value, "%lu %llu",
					&current->frequency,
					&current->time_in_state) != 2)
				goto error_out;

			*total_time = *total_time + current->time_in_state;
			pos = i + 1;
		}
	}

	return first;

 error_out:
	while (first) {
		current = first->next;
		free(first);
		first = current;
	}
	return NULL;
}

void cpufreq_put_stats(struct cpufreq_stats *any)
{
	struct cpufreq_stats *tmp, *next;

	if (!any)
		return;

	tmp = any->first;
	while (tmp) {
		next = tmp->next;
		free(tmp);
		tmp = next;
	}
}

unsigned long cpufreq_get_transitions(unsigned int cpu)
{
	return sysfs_cpufreq_get_one_value(cpu, STATS_NUM_TRANSITIONS);
}


s = String(left_operand.applyRow(datarow, getter).getValue());
			var right_res = new RegExp(right_operand.applyRow(datarow, getter).getValue());
			return new exprs.BooleanExpr(left_res.search(right_res) >= 0);	//_ConditionExpr
		}
	});
	var IsEmpty = declare("dojox.grid.enhanced.plugins.filter.IsEmpty", exprs._UniOpExpr, {
		// summary:
		//		Check empty
		_name: "isEmpty",
		_calculate: function(/* _ConditionExpr */operand,/* data item*/datarow,/* function(row,colIdx) */getter){
			// summary:
			//		Override from _BiOpExpr
			var res = operand.applyRow(datarow, getter).getValue();
			return new exprs.BooleanExpr(res === "" || res == null);
		}
	});

	return lang.mixin({
		LogicAND: LogicAND,
		LogicOR: LogicOR,
		LogicXOR: LogicXOR,
		LogicNOT: LogicNOT,
		LogicALL: LogicALL,
		LogicANY: LogicANY,
		EqualTo: EqualTo,
		LessThan: LessThan,
		LessThanOrEqualTo: LessThanOrEqualTo,
		LargerThan: LargerThan,
		LargerThanOrEqualTo: LargerThanOrEqualTo,
		Contains: Contains,
		StartsWith: StartsWith,
		EndsWith: EndsWith,
		Matches: Matches,
		IsEmpty: IsEmpty
	}, exprs);
});
var formatDate = function(inDatum){
	var dtb = new dijit.form.DateTextBox({});
	var res = dojo.date.locale.parse(inDatum,{
		selector: "date",
		datePattern: "yyyy/MM/dd"
	});
	dtb.set("value",res);
	return dtb;
};
this.layout = [
	[{//--------------------------------------------------------------------------0
		defaultCell: {editable: true, autoComplete:true, type: dojox.grid.cells._Widget},
		cells:
		[
			{ field: "id", name:"Index", datatype:"number", width: 2.5},
			{ field: "Genre", name:"Genre", datatype:"string", width: 10},
			{ field: "Artist", name:"Artist", datatype:"string", width: 10},
			{ field: "Year", name:"Year", datatype:"string", width: 2.5},
			{ field: "Album", name:"Album", datatype:"string", width: 10},
			{ field: "Name", name:"Name", datatype:"string", width: 8, disabledConditions: [
				"contains", "notcontains"
			]},
			{ field: "Length", name:"Length", datatype:"string", width: 4},
			{ field: "Track", name:"Track", datatype:"number", width: 3
//				,get: function(rowIndex, item){
//					if(item){
//						return "Track " + this.grid.store.getValue(item, this.field);
//					}else{
//						return this.value || this.defaultValue;
//					}
//				}
			},
			{ field: "Composer", name:"Composer", datatype:"string", width: 12},
			{ field: "Download Date", name:"Download Date", datatype:"date", width: 12,
				navigatable: true, editable: false,
				//formatter: formatDate,
				dataTypeArgs: {
					datePattern: "yyyy/M/d"
				}
			},
			{ field: "Last Played", name:"Last Played", datatype:"time", width: 6,
				dataTypeArgs: {
					timePattern: "HH:mm:ss"
				}
			},
			{ field: "Heard", name: "Checked", datatype:"boolean", width: 6/*, type: dojox.grid.cells.CheckBox*/},
			{ field: "Checked", name:"Checked (Customized Label)", editable: false, datatype:"boolean", width: 15, dataTypeArgs: {


ック
  get amount() {
    let result = 40000;
    if (this.performance.audience > 30) {
      result += 1000 * (this.performance.audience - 30);
    }
    return result;
  }
  // Point計算ロジック(superと同様)
}

const createPerformanceCalculator = (
  aPerformance: Perfomance,
  aPlay: SinglePlay
) => {
  switch (aPlay.type) {
    case "tragedy":
      return new TragedyPerformanceCalculator(aPerformance, aPlay);
    case "comedy":
      return new ComedyPerformanceCalculator(aPerformance, aPlay);
    default:
      throw new Error("Unrecognized type.");
  }
};

export const createStatementData = (invoice: Invoice, plays: Play) => {
  // play取得
  const playFor = (aPerformance: Perfomance) => {
    return plays[aPerformance.playID];
  };
  // 総ポイント集計
  const totalVolumeCredits = (data: StatementData) => {
    return data.performances.reduce(
      (total, aPerformance) => aPerformance.volumeCredits + total,
      0
    );
  };
  // 総金額集計
  const totalAmount = (data: StatementData) => {
    return data.performances.reduce(
      (total, aPerformance) => aPerformance.amount + total,
      0
    );
  };

  const statementData: StatementData = {
    customer: invoice.customer,
    performances: invoice.performances.map((aPerformance) => {
      const calculator = createPerformanceCalculator(
        aPerformance,
        playFor(aPerformance)
      );
      const result: EnrichedPerformance = {
        ...aPerformance,
        play: calculator.play,
        amount: calculator.amount,
        volumeCredits: calculator.volumeCredit,
      };
      return result;
    }),
    totalAmount: 0,
    totalVolumeCredits: 0,
  };
  statementData.totalAmount = totalAmount(statementData);
  statementData.totalVolumeCredits = totalVolumeCredits(statementData);
  return statementData;
};
import { Post } from 'views/MainPage/MainPage';

export const postFilter = (
  isTitle: boolean,
  isDescription: boolean,
  isTags: boolean,
  value: string,
  post: Post
) => {
  if (isTitle && isDescription && isTags) {
    if (
      post.title.toLowerCase().includes(value.toLowerCase()) ||
      post.description.toLowerCase().includes(value.toLowerCase()) ||
      post.tags.toLowerCase().includes(value.toLowerCase())
    ) {
      return post;
    }
  } else if (isTitle && isDescription) {
    if (
      post.title.toLowerCase().includes(value.toLowerCase()) ||
      post.description.toLowerCase().includes(value.toLowerCase())
    ) {
      return post;
    }
  } else if (isTitle && isTags) {
    if (
      post.title.toLowerCase().includes(value.toLowerCase()) ||
      post.tags.toLowerCase().includes(value.toLowerCase())
    ) {
      return post;
    }
  } else if (isDescription && isTags) {
    if (
      post.description.toLowerCase().includes(value.toLowerCase()) ||
      post.tags.toLowerCase().includes(value.toLowerCase())
    ) {
      return post;
    }
  } else if (isTitle) {
    if (post.title.toLowerCase().includes(value.toLowerCase())) {
      return post;
    }
  } else if (isDescription) {
    if (post.description.toLowerCase().includes(value.toLowerCase())) {
      return post;
    }
  } else if (isTags) {
    if (post.tags.toLowerCase().includes(value.toLowerCa


ation", "UpstreamAttenuation", adjustScale},
  ["pwr"] = {"DownstreamPower", "UpstreamPower", adjustScale},
  ["framing_msgc"] = {"DownstreamFramingMSGc", "UpstreamFramingMSGc"},
  ["framing_b"] = {"DownstreamFramingB", "UpstreamFramingB"},
  ["framing_m"] = {"DownstreamFramingM", "UpstreamFramingM"},
  ["framing_t"] = {"DownstreamFramingT", "UpstreamFramingT"},
  ["framing_r"] = {"DownstreamFramingR", "UpstreamFramingR"},
  ["framing_s"] = {"DownstreamFramingS", "UpstreamFramingS"},
  ["framing_l"] = {"DownstreamFramingL", "UpstreamFramingL"},
  ["framing_d"] = {"DownstreamInterleaveDepth", "UpstreamInterleaveDepth"},
  ["framing_i"] = {"DownstreamFramingI", "UpstreamFramingI"},
  ["framing_n"] = {"DownstreamFramingN", "UpstreamFramingN"},
  ["framing_q"] = {"DownstreamFramingQ", "UpstreamFramingQ"},
  ["framing_V"] = {"DownstreamFramingV", "UpstreamFramingV"},
  ["framing_K"] = {"DownstreamFramingK", "UpstreamFramingK"},
  ["counters_ohf"] = {"OHFDs", "OHFUs"},
  ["counters_ohferr"] = {"OHFErrDs", "OHFErrUs"},
  ["counters_sf"] = {"SFDs", "SFUs"},
  ["counters_sferr"] = {"SFErrDs", "SFErrUs"},
  ["counters_rs"] = {"RSDs", "RSUs"},
  ["counters_rscorr"] = {"RSCorrDs", "RSCorrUs"},
  ["counters_rsuncorr"] = {"RSUnCorrDs", "RSUnCorrUs"},
  ["counters_hec"] = {"ShowtimeXTURHECErrors", "ShowtimeXTUCHECErrors"},
  ["counters_ocd"] = {"OCDDs", "OCDUs"},
  ["counters_lcd"] = {"LCDDs", "LCDUs"},
  ["counters_totalcells"] = {"BytesReceived", "BytesSent"},
  ["counters_datacells"] = {"PacketsReceived", "PacketsSent"},
  ["counters_dropcells"] = {"DiscardPacketsReceived", "DiscardPacketsSent"},
  ["counters_biterr"] = {"ErrorsReceived", "ErrorsSent"},
  ["counters_es"] = {"ShowtimeErroredSecsDs", "ShowtimeErroredSecsUs"},
  ["counters_ses"] = {"ShowtimeSeverelyErroredSecsDs", "ShowtimeSeverelyErroredSecsUs"},
  ["counters_uas"] = {"ShowtimeUnavailableSecsDs", "ShowtimeUnavailableSecsUs"},
  ["counters_as"] = {"ShowtimeAvailableSecs"},
  ["counters_inp"] = {"INPDs", "INPUs"},
  ["counters_inprein"] = {"INPReinDs", "INPReinUs"},
  ["counters_delay"] = {"DownstreamDelay", "UpstreamDelay"},
  ["counters_per"] = {"PERDs", "PERUs"},
  ["counters_or"] = {"ORDs", "ORUs"},
  ["counters_agr"] = {"AGRDs", "AGRUs"},
  ["counters_bitsw"] = {"BitswapDs", "BitswapUs"},
  ["counters_noisemargin"] = {"DownstreamNoiseMargin", "UpstreamNoiseMargin"},
  ["ginp_q"] = {"Qds", "Qus"},
  ["ginp_v"] = {"Vds", "Vus"},
  ["ginp_rxqueue"] = {"RxQueueds", "RxQueueus"},
  ["ginp_txqueue"] = {"TxQueueds", "TxQueueus"},
  ["ginp_rtxmode"] = {"RTxModeds", "RTxModeus"},
  ["ginp_lookback"] = {"LookBackds", "LookBackus"},
  ["ginp_rrcbits"] = {"RRCBitsds", "RRCBitsus"},
  ["ginp_rtxtx"] = {"RTxTxds", "RTxTxus"},
  ["ginp_rtxc"] = {"RTxCds", "RTxCus"},
  ["ginp_


Buy Signal",
                )

            # 繪製賣出訊號
            sell_signals = stock_signals[stock_signals["signal"] == -1]
            if not sell_signals.empty:
                ax.scatter(
                    sell_signals.index,
                    stock_price.loc[sell_signals.index],
                    marker="v",
                    color="red",
                    s=100,
                    label="Sell Signal",
                )

            # 設置圖表標題和標籤
            ax.set_title(f"{stock_id} - {strategy_name} Strategy")
            ax.set_xlabel("Date")
            ax.set_ylabel("Price")
            ax.legend()
            ax.grid(True)

        # 調整佈局
        plt.tight_layout()

        return fig


ns
        coEvery { tracker.setNumSafes(any()) } just Runs
        coEvery { credentialsRepository.ownerCount() } returns 0
        coEvery { settingsHandler.showOwnerScreen } returns true

        viewModel.submitAddressAndName(VALID_SAFE_ADDRESS, "Name", rinkeby)

        viewModel.state.test()
            .assertValues(
                AddSafeNameState(ImportOwner)
            )
        coVerifySequence {
            safeRepository.saveSafe(Safe(VALID_SAFE_ADDRESS, "Name", rinkeby.chainId))
            chainInfoRepository.save(rinkeby)
            notificationRepository.registerSafes(Safe(VALID_SAFE_ADDRESS, "Name", rinkeby.chainId))
            notificationManager.createNotificationChannelGroup(Safe(VALID_SAFE_ADDRESS, "Name", rinkeby.chainId))
            safeRepository.setActiveSafe(Safe(VALID_SAFE_ADDRESS, "Name", rinkeby.chainId))
            tracker.logSafeAdded(any())
            safeRepository.getSafeCount()
            tracker.setNumSafes(0)
            settingsHandler.showOwnerScreen
            credentialsRepository.ownerCount()
        }
    }

    companion object {
        private val VALID_SAFE_ADDRESS = "0xA7e15e2e76Ab469F8681b576cFF168F37Aa246EC".asEthereumAddress()!!
    }
}
package io.gnosis.safe.ui.assets.collectibles

import androidx.paging.PagingData
import io.gnosis.data.models.Chain
import io.gnosis.data.models.Safe
import io.gnosis.data.models.assets.Collectible
import io.gnosis.data.repositories.SafeRepository
import io.gnosis.safe.*
import io.gnosis.safe.ui.assets.collectibles.paging.CollectiblePagingProvider
import io.gnosis.safe.ui.base.BaseStateViewModel
import io.mockk.coEvery
import io.mockk.coVerifySequence
import io.mockk.mockk
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.runTest
import org.junit.Assert.assertEquals
import org.junit.Rule
import org.junit.Test
import pm.gnosis.model.Solidity
import java.math.BigInteger

class CollectiblesViewModelTest {

    @get:Rule
    val instantExecutorRule = TestLifecycleRule()

    private lateinit var viewModel: CollectiblesViewModel

    private val collectiblesPager = mockk<CollectiblePagingProvider>()
    private val safeRepository = mockk<SafeRepository>()

    @Test
    fun `init - should call load on safe change`() {
        val safe1 = Safe(Solidity.Address(BigInteger.ONE), "safe1")
        val safe10 = Safe(Solidity.Address(BigInteger.TEN), "safe10")
        coEvery { safeRepository.activeSafeFlow() } returns flow {
            emit(safe1)
            emit(safe10)
        }
        coEvery { safeRepository.getActiveSafe() } returnsMany listOf(safe1, safe10)

        coEvery { collectiblesPager.getCollectiblesStream(any()) } returns flow {
            emit(PagingData.empty<Collectible>())
        }

        viewModel = CollectiblesViewModel(collectiblesPager, safeRepository, appDispatchers)

        coVerifySequence {
            safeRepository.activeSafeFlow()
            safeRepository.getActiveSafe()
            collectiblesPager.getCollectiblesStream(safe1)
            safeRepository.getActiveSafe()
            collectiblesPager.getCollectiblesStream(safe10)
        }
    }

    @Test
    fun `load - should emit collectibles view data list`() = runTest(UnconfinedTestDispatcher()) {
        val stateObserver = TestLiveDataObserver<BaseStateViewModel.State>()
        val chain = Chain.DEFAULT_CHAIN
        val collectibles = buildCollectibleList()
        val safe = Safe(Solidity.Address(BigInteger.ONE), "safe1").apply {


** @type {function(...*):?} */
var dynCall_viiiiifff = Module["dynCall_viiiiifff"] = createExportWrapper("dynCall_viiiiifff");

/** @type {function(...*):?} */
var dynCall_ji = Module["dynCall_ji"] = createExportWrapper("dynCall_ji");

/** @type {function(...*):?} */
var dynCall_vidd = Module["dynCall_vidd"] = createExportWrapper("dynCall_vidd");

/** @type {function(...*):?} */
var dynCall_jijii = Module["dynCall_jijii"] = createExportWrapper("dynCall_jijii");

/** @type {function(...*):?} */
var dynCall_fff = Module["dynCall_fff"] = createExportWrapper("dynCall_fff");

/** @type {function(...*):?} */
var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji");

/** @type {function(...*):?} */
var dynCall_iidiiii = Module["dynCall_iidiiii"] = createExportWrapper("dynCall_iidiiii");

/** @type {function(...*):?} */
var dynCall_vffff = Module["dynCall_vffff"] = createExportWrapper("dynCall_vffff");

/** @type {function(...*):?} */
var dynCall_vf = Module["dynCall_vf"] = createExportWrapper("dynCall_vf");

/** @type {function(...*):?} */
var dynCall_viiiiiiii = Module["dynCall_viiiiiiii"] = createExportWrapper("dynCall_viiiiiiii");

/** @type {function(...*):?} */
var dynCall_viiiiiiiii = Module["dynCall_viiiiiiiii"] = createExportWrapper("dynCall_viiiiiiiii");

/** @type {function(...*):?} */
var dynCall_vff = Module["dynCall_vff"] = createExportWrapper("dynCall_vff");

/** @type {function(...*):?} */
var dynCall_vfi = Module["dynCall_vfi"] = createExportWrapper("dynCall_vfi");

/** @type {function(...*):?} */
var __growWasmMemory = Module["__growWasmMemory"] = createExportWrapper("__growWasmMemory");

/** @type {function(...*):?} */
var _asyncify_start_unwind = Module["_asyncify_start_unwind"] = createExportWrapper("asyncify_start_unwind");

/** @type {function(...*):?} */
var _asyncify_stop_unwind = Module["_asyncify_stop_unwind"] = createExportWrapper("asyncify_stop_unwind");

/** @type {function(...*):?} */
var _asyncify_start_rewind = Module["_asyncify_start_rewind"] = createExportWrapper("asyncify_start_rewind");

/** @type {function(...*):?} */
var _asyncify_stop_rewind = Module["_asyncify_stop_rewind"] = createExportWrapper("asyncify_stop_rewind");

function invoke_ii(index,a1) {
  var sp = stackSave();
  try {
    return dynCall_ii(index,a1);
  } catch(e) {
    stackRestore(sp);
    if (e !== e+0 && e !== 'longjmp') throw e;
    _setThrew(1, 0);
  }
}

function invoke_vii(index,a1,a2) {
  var sp = stackSave();
  try {
    dynCall_vii(index,a1,a2);
  } catch(e) {
    stackRestore(sp);
    if (e !== e+0 && e !== 'longjmp') throw e;
    _setThrew(1, 0);
  }
}

function invoke_vi(index,a1) {
  var sp = stackSave();
  try {
    dynCall_vi(index,


 = Long.rotateLeft(h2,31);
      h2 += h1;
      h2 = h2*5+0x38495ab5;
    }

    long k1 = 0;
    long k2 = 0;

    // tail
    switch ((int)length & 15) {
      case 15: k2  = (PlatformDependent.getByte(roundedEnd+14) & 0xffL) << 48;
      case 14: k2 ^= (PlatformDependent.getByte(roundedEnd+13) & 0xffL) << 40;
      case 13: k2 ^= (PlatformDependent.getByte(roundedEnd+12) & 0xffL) << 32;
      case 12: k2 ^= (PlatformDependent.getByte(roundedEnd+11) & 0xffL) << 24;
      case 11: k2 ^= (PlatformDependent.getByte(roundedEnd+10) & 0xffL) << 16;
      case 10: k2 ^= (PlatformDependent.getByte(roundedEnd+ 9) & 0xffL) << 8;
      case  9: k2 ^= (PlatformDependent.getByte(roundedEnd+ 8) & 0xffL);
        k2 *= c2;
        k2  = Long.rotateLeft(k2, 33);
        k2 *= c1;
        h2 ^= k2;
      case  8: k1  = (long)PlatformDependent.getByte(roundedEnd+7) << 56;
      case  7: k1 ^= (PlatformDependent.getByte(roundedEnd+6) & 0xffL) << 48;
      case  6: k1 ^= (PlatformDependent.getByte(roundedEnd+5) & 0xffL) << 40;
      case  5: k1 ^= (PlatformDependent.getByte(roundedEnd+4) & 0xffL) << 32;
      case  4: k1 ^= (PlatformDependent.getByte(roundedEnd+3) & 0xffL) << 24;
      case  3: k1 ^= (PlatformDependent.getByte(roundedEnd+2) & 0xffL) << 16;
      case  2: k1 ^= (PlatformDependent.getByte(roundedEnd+1) & 0xffL) << 8;
      case  1: k1 ^= (PlatformDependent.getByte(roundedEnd ) & 0xffL);
        k1 *= c1;
        k1  = Long.rotateLeft(k1,31);
        k1 *= c2;
        h1 ^= k1;
    }

    h1 ^= length;
    h2 ^= length;

    h1 += h2;
    h2 += h1;

    h1 = fmix64(h1);
    h2 = fmix64(h2);

    h1 += h2;
    h2 += h1;
    // murmur3_128 should return 128 bit (h1,h2), now we return only 64bits,
    return h1;
  }

  public static long murmur3_64(long val, int seed) {

    long h1 = seed & 0x00000000FFFFFFFFL;
    long h2 = seed & 0x00000000FFFFFFFFL;

    final long c1 = 0x87c37b91114253d5L;
    final long c2 = 0x4cf5ad432745937fL;

    int length = 8;
    long k1 = 0;

    k1 = val;
    k1 *= c1;
    k1  = Long.rotateLeft(k1,31);
    k1 *= c2;
    h1 ^= k1;

    h1 ^= length;
    h2 ^= length;

    h1 += h2;
    h2 += h1;

    h1 = fmix64(h1);
    h2 = fmix64(h2);

    h1 += h2;

    //h2 += h1;
    // murmur3_128 should return 128 bit (h1,h2), now we return only 64bits,
    return h1;

  }

  public static int murmur3_32(int bStart, int bEnd, DrillBuf bu


}
                },
                Event::MouseWheel {delta} => {
                    camera_handler.zoom(&mut camera, *delta as f32);
                },
                Event::MouseMotion {delta} => {
                    camera_handler.rotate(&mut camera, delta.0 as f32, delta.1 as f32);
                    if let Some(ref w) = weights
                    {
                        on_morph(&mut mesh, w, 0.001 * delta.1);
                        let positions: Vec<f32> = mesh.positions_buffer().iter().map(|v| *v as f32).collect();
                        let normals: Vec<f32> = mesh.normals_buffer().iter().map(|v| *v as f32).collect();
                        wireframe_model.update_positions(&positions);
                        model.update_attributes(&att!["position" => (positions, 3), "normal" => (normals, 3)]).unwrap();
                    }
                }
            }
        }

        // Draw
        let render_scene = |camera: &Camera| {
            let model_matrix = dust::Mat4::identity();
            model.render(&model_matrix, camera);
            wireframe_model.render(camera);
        };

        // Shadow pass
        light1.shadow_cast_begin().unwrap();
        render_scene(light1.shadow_camera().unwrap());

        light2.shadow_cast_begin().unwrap();
        render_scene(light2.shadow_camera().unwrap());

        light3.shadow_cast_begin().unwrap();
        render_scene(light3.shadow_camera().unwrap());

        light4.shadow_cast_begin().unwrap();
        render_scene(light4.shadow_camera().unwrap());

        // Geometry pass
        renderer.geometry_pass_begin().unwrap();
        render_scene(&camera);
        plane.render(&dust::Mat4::from_scale(100.0), &camera);

        // Light pass
        renderer.light_pass_begin(&camera).unwrap();
        renderer.shine_ambient_light(&ambient_light).unwrap();
        renderer.shine_spot_light(&light1).unwrap();
        renderer.shine_spot_light(&light2).unwrap();
        renderer.shine_spot_light(&light3).unwrap();
        renderer.shine_spot_light(&light4).unwrap();

        renderer.copy_to_screen().unwrap();
    }).unwrap();
}<reponame>sifraitech/kzg<gh_stars>10-100
pub mod local_tests;
<filename>tests/reference.rs
mod common;

use dsgit::commit::Commit;
use serial_test::serial;
use std::fs;
use std::io;
use std::path::Path;

use common::{assert_file_contents, setup, DSGIT_DIR};
use dsgit::reference;
use dsgit::reference::RefValue;

#[test]
#[serial]
fn switch() {
    fn assert_number_files(expected: usize) {
        let files = fs::read_dir(".")
            .unwrap()
            .map(|res| res.map(|e| e.path()))
            .collect::<Result<Vec<_>, io::Error>>()
            .unwrap();
        assert_eq!(files.len(), expected);
    }
    setup();
    let oid1 = Commit::commit("1st commit", &[]).unwrap();
    assert_number_files(5);

    // Create a new file.
    fs::write("./foo.txt", "foo bar").unwrap();
    Commit::commit("2nd


Config => ".config.json",
        }
    }

    pub const fn mimetype(&self) -> MimeType {
        match self {
            Self::Png => MimeType::ImagePng,
            _ => MimeType::TextPlain,
        }
    }
}

impl From<ExportMethod> for Html {
    fn from(x: ExportMethod) -> Self {
        html! {
            { x.as_filename() }
        }
    }
}

impl ExportMethod {
    pub fn new_file(&self, x: &str) -> ExportFile {
        ExportFile {
            name: Rc::new(x.to_owned()),
            method: *self,
        }
    }
}

#[derive(Clone, PartialEq)]
pub struct ExportFile {
    pub name: Rc<String>,
    pub method: ExportMethod,
}

impl ExportFile {
    pub fn as_filename(&self) -> String {
        format!("{}{}", self.name, self.method.as_filename())
    }
}

impl From<ExportFile> for Html {
    fn from(x: ExportFile) -> Self {
        let class = if x.name.is_empty() {
            Some("invalid")
        } else {
            None
        };

        html_template! {

                { x.name }
                { x.method.as_filename() }

        }
    }
}
use lazy_static::lazy_static;
use pest::prec_climber::{Assoc, Operator, PrecClimber};

use std::str::FromStr;

use super::*;

// Parses an expression.
pub fn parse_expr(mut pairs: Pairs<'static, Rule>) -> ast::Expr {
    let pair = pairs.next().unwrap();

    match pair.as_rule() {
        Rule::binexpr => parse_binexpr(pair.into_inner()),
        Rule::ternary => parse_ternary(pair.into_inner()),
        Rule::term => parse_term(pair.into_inner()),
        _ => unreachable!(),
    }
}

lazy_static! {
    // The precedence climber for the expression grammar.
    static ref PREC_CLIMBER: PrecClimber<Rule> = {
        use Rule::*;
        use Assoc::*;

        PrecClimber::new(vec![
            Operator::new(or, Left),
            Operator::new(and, Left),
            Operator::new(bitor, Left),
            Operator::new(xor, Left),
            Operator::new(bitand, Left),
            Operator::new(eq, Left) | Operator::new(neq, Left),
            Operator::new(leq, Left) | Operator::new(geq, Left) | Operator::new(lt, Left) | Operator::new(gt, Left),
            Operator::new(shl, Left) | Operator::new(shr, Left),
            Operator::new(add, Left) | Operator::new(sub, Left),
            Operator::new(mul, Left) | Operator::new(div, Left) | Operator::new(mod_, Left),
        ])
    };
}

// Parses a binary expression.
pub fn parse_binexpr(pairs: Pairs<'static, Rule>) -> ast::Expr {
    PREC_CLIMBER.climb(
        pairs,
        |pair| parse_term(pair.into_inner()),
        |left, op, right| ast::Expr::BinExpr(Box::new(ast::BinExpr {
            left,
            op: parse_binop(op),
            right,
        })),
    )
}

// Parses a binary operator.
pub fn parse_binop(pair: Pair<'_, Rule>) -> ast::BinOp {
    match pair.as_rule() {
        Rule::add => ast::BinOp::Add,
        Rule::sub => ast::BinOp


erOfExtraBytesToRead(firstByte);
    long retval = firstByte & firstByteValueMask(size);
    for (int ii = 0; ii < size; ii++) {
      byte b = input.readByte();
      retval <<= 8;
      retval |= b & 0xff;
    }

    return retval;
  }

  static long readVInt(DataInput input) throws IOException {
    return decodeZigZag64(readUnsignedVInt(input));
  }

  // & this with the first byte to give the value part for a given extraBytesToRead encoded in the
  // byte
  private static int firstByteValueMask(int extraBytesToRead) {
    // by including the known 0bit in the mask, we can use this for encodeExtraBytesToRead
    return 0xff >> extraBytesToRead;
  }

  private static byte encodeExtraBytesToRead(int extraBytesToRead) {
    // because we have an extra bit in the value mask, we just need to invert it
    return (byte) ~firstByteValueMask(extraBytesToRead);
  }

  private static int numberOfExtraBytesToRead(int firstByte) {
    // we count number of set upper bits; so if we simply invert all of the bits, we're golden
    // this is aided by the fact that we only work with negative numbers, so when upcast to an int
    // all
    // of the new upper bits are also set, so by inverting we set all of them to zero
    return Integer.numberOfLeadingZeros(~firstByte) - 24;
  }

  private static void writeUnsignedVInt(long value, DataOutput output) throws IOException {
    int size = VIntCoding.computeUnsignedVIntSize(value);
    if (size == 1) {
      output.write((int) value);
      return;
    }

    output.write(VIntCoding.encodeVInt(value, size), 0, size);
  }

  private static byte[] encodeVInt(long value, int size) {
    byte[] encodingSpace = new byte[9];
    int extraBytes = size - 1;

    for (int i = extraBytes; i >= 0; --i) {
      encodingSpace[i] = (byte) value;
      value >>= 8;
    }
    encodingSpace[0] |= encodeExtraBytesToRead(extraBytes);
    return encodingSpace;
  }

  static void writeVInt(long value, DataOutput output) throws IOException {
    writeUnsignedVInt(encodeZigZag64(value), output);
  }

  /**
   * Decode a ZigZag-encoded 64-bit value. ZigZag encodes signed integers into values that can be
   * efficiently encoded with varint. (Otherwise, negative values must be sign-extended to 64 bits
   * to be varint encoded, thus always taking 10 bytes on the wire.)
   *
   * @param n an unsigned 64-bit integer, stored in a signed int because Java has no explicit
   *     unsigned support.
   * @return a signed 64-bit integer.
   */
  private static long decodeZigZag64(final long n) {
    return (n >>> 1) ^ -(n & 1);
  }

  /**
   * Encode a ZigZag-encoded 64-bit value. ZigZag encodes signed integers into values that can be
   * efficiently encoded with varint. (Otherwise, negative values must be sign-extended to 64 bits
   * to be varint encoded, thus always taking 10 bytes on the wire.)
   *
   * @param n a signed 64-bit integer.
   * @return an unsigned 64-bit integer, stored in a signed int because Java has no explicit
   *     unsigned support.
   */
  private static long encodeZigZag64(final long n) {
    // Note:  the right-shift must be arithmetic
    return (n << 1) ^ (n >> 63);
  }

  /** Compute the number of bytes that would be needed to encode a varint. */
  static int computeVIntSize(final long param) {
    return computeUnsignedVIntSize(encodeZigZag64(param));
  }

  /** Compute the number of bytes that would be needed to encode an unsigned varint. */
  private static int computeUnsignedVIntSize(final long value) {
    int magnitude =
        Long.numberOfLeadingZeros(
            value | 1); // | with 1 to ensure magnitude <= 63, so (63 - 1) / 7 <= 8
    return (639 - magnitude * 9) >> 6;
  }
}
package io.stargate.db.dse.


                            ) {
                                val hash = ""
                                initNewTagDialog(hash)
                            }
                        }
                    }
                }

            }else {  //有条目
                //根据关键字过滤条目
                val keyword = filterKeyword.value.text  //关键字
                val enableFilter = filterModeActuallyEnabled(filterModeOn.value, keyword)

                val lastNeedRefresh = rememberSaveable { mutableStateOf("") }
                val list = filterTheList(
                    needRefresh = filterResultNeedRefresh.value,
                    lastNeedRefresh = lastNeedRefresh,
                    enableFilter = enableFilter,
                    keyword = keyword,
                    lastKeyword = lastKeyword,
                    searching = searching,
                    token = token,
                    activityContext = activityContext,
                    filterList = filterList.value,
                    list = list.value,
                    resetSearchVars = resetSearchVars,
                    match = { idx:Int, it: TagDto ->
                        it.shortName.contains(keyword, ignoreCase = true)
                                || it.name.contains(keyword, ignoreCase = true)
                                || it.msg.contains(keyword, ignoreCase = true)
                                || it.targetFullOidStr.contains(keyword, ignoreCase = true)
                                || it.taggerName.contains(keyword, ignoreCase = true)
                                || it.taggerEmail.contains(keyword, ignoreCase = true)

                                // annotated tag对象的oid；非annotated tag此值和targetFullOidStr一样
                                || it.fullOidStr.contains(keyword, ignoreCase = true)

                                || it.pointedCommitDto.let { commit ->
                                    if(commit == null) {
                                        false
                                    }else {
                                        commit.msg.contains(keyword, ignoreCase = true)
                                                || commit.getFormattedAuthorInfo().contains(keyword, ignoreCase = true)
                                                || commit.dateTime.contains(keyword, ignoreCase = true)
                                    }
                                }
                                || it.getFormattedDate().contains(keyword, ignoreCase = true)
                                || it.getFormattedTaggerNameAndEmail().contains(keyword, ignoreCase = true)
                                || it.getType(activityContext, false).contains(keyword, ignoreCase = true)
                                || it.getType(activityContext, true).contains(keyword, ignoreCase = true)
                                || it.getOriginTimeOffsetFormatted().contains(keyword, ignoreCase = true)
                    }
                )

                val listState = if(enableFilter) filterListState else listState
//            if(enableFilter) {  //更新filter列表state
//                filterListState.value = listState
//            }
                //更新是否启用filter
                enableFilterState.value = enableFilter

                MyLazyColumn(
                    contentPadding = contentPadding,
                    list = list,
                    listState = listState,
                    requireForEachWithIndex = true,
                    requirePaddingAtBottom = true,
                    forEachCb = {},
                ){idx, it->
                    //长按会更新curObjInPage为被长按的条目
                    TagItem(
                        thisObj = it,
                        lastClickedItemKey = lastClickedItemKey,
                        shouldShowTimeZoneInfo = shouldShowTimeZoneInfo,
                        showItemMsg = showItemMsg,
                        isItemInSelected = isItemInSelected,
                        onLongClick = {
                            if(multiSelectionMode.value) {  //多选模式
                                //在选择模式下长按条目，执行区域选择（连续选择一个范围）
                                UIHelper.doSelectSpan(idx, it,
                                    selectedItemList.value, list,
                                    switchItemSelected,
                                    selectItem
                                )
                            }else {  //非多选模式
                                //启动多选模式
                                switchItemSelected(it)
                            }
                        }
                    ) {


                    (Usize(Us64(a)), Usize(Us64(b))) => Ok(Usize(Us64(a.$func(b)))),
                    _ => Err(UnequalTypes(Op::$op)),
                }
            }
        }
    }
}

impl_binop!(Add, add, checked_add);
impl_binop!(Sub, sub, checked_sub);
impl_binop!(Mul, mul, checked_mul);
derive_binop!(BitAnd, bitand);
derive_binop!(BitOr, bitor);
derive_binop!(BitXor, bitxor);

const I128_MIN: i128 = ::std::i128::MIN;

fn check_division(
    lhs: ConstInt,
    rhs: ConstInt,
    op: Op,
    zerr: ConstMathErr,
) -> Result<(), ConstMathErr> {
    match (lhs, rhs) {
        (I8(_), I8(0)) => Err(zerr),
        (I16(_), I16(0)) => Err(zerr),
        (I32(_), I32(0)) => Err(zerr),
        (I64(_), I64(0)) => Err(zerr),
        (I128(_), I128(0)) => Err(zerr),
        (Isize(_), Isize(Is16(0))) => Err(zerr),
        (Isize(_), Isize(Is32(0))) => Err(zerr),
        (Isize(_), Isize(Is64(0))) => Err(zerr),

        (U8(_), U8(0)) => Err(zerr),
        (U16(_), U16(0)) => Err(zerr),
        (U32(_), U32(0)) => Err(zerr),
        (U64(_), U64(0)) => Err(zerr),
        (U128(_), U128(0)) => Err(zerr),
        (Usize(_), Usize(Us16(0))) => Err(zerr),
        (Usize(_), Usize(Us32(0))) => Err(zerr),
        (Usize(_), Usize(Us64(0))) => Err(zerr),

        (I8(::std::i8::MIN), I8(-1)) => Err(Overflow(op)),
        (I16(::std::i16::MIN), I16(-1)) => Err(Overflow(op)),
        (I32(::std::i32::MIN), I32(-1)) => Err(Overflow(op)),
        (I64(::std::i64::MIN), I64(-1)) => Err(Overflow(op)),
        (I128(I128_MIN), I128(-1)) => Err(Overflow(op)),
        (Isize(Is16(::std::i16::MIN)), Isize(Is16(-1))) => Err(Overflow(op)),
        (Isize(Is32(::std::i32::MIN)), Isize(Is32(-1))) => Err(Overflow(op)),
        (Isize(Is64(::std::i64::MIN)), Isize(Is64(-1))) => Err(Overflow(op)),

        _ => Ok(()),
    }
}

impl ::std::ops::Div for ConstInt {
    type Output = Result<Self, ConstMathErr>;
    fn div(self, rhs: Self) -> Result<Self, ConstMathErr> {
        let (lhs, rhs) = (self, rhs);
        check_division(lhs, rhs, Op::Div, DivisionByZero)?;
        match (lhs, rhs) {
            (I8(a), I8(b)) => Ok(I8(a/b)),
            (I16(a), I16(b)) => Ok(I16(a/b)),
            (I32(a), I32(b)) => Ok(I32(a/b)),
            (I64(a), I64(b)) => Ok(I64(a/b)),
            (I128(a), I128(b)) => Ok(I128(a/b)),


ors:
.byte 37
.res 7, 0

; sector info
secNumVerts:
.byte 8, 6, 6, 6, 5, 4, 4, 4, 4, 4, 4, 7, 6, 7, 4, 4
.byte 5, 4, 6, 5, 4, 4, 4, 5, 6, 4, 6, 4, 4, 4, 4, 5
.byte 4, 5, 5, 5, 6, 4, 8, 4, 5, 4, 4, 4, 4, 5, 4, 5
.byte 6, 4, 6
.res 13, 0

; object data
objXhi:
.byte -12, -6, 26, -7, 38, -11, -8, -55, -61, -61, -51, -51, -48, -49, -49, -48
.byte -48, -46, -50, -46, -21, -20, -55, 7, 29, 60, 35, 43, 12, -14, 9, 7
.byte -12, -3, -12, 37, 45, 6, 19, 3, 52, -47, -46, 45, -39, -5
.res 2, 0

objYhi:
.byte -41, -41, -4, -30, -7, 1, -6, -16, -7, 0, 0, -6, 20, -23, -2, 2
.byte -8, -22, 17, 16, -17, 11, 9, 5, 21, 18, 9, 10, -3, 38, 36, 42
.byte 32, 51, 52, -22, -12, -10, -28, 5, 13, -26, 19, -7, -9, 17
.res 2, 0

objType:
.byte 15, 15, 9, 0, 0, 15, 15, 12, 12, 12, 13, 13, 5, 8, 15, 1
.byte 1, 2, 1, 1, 0, 0, 12, 11, 1, 1, 2, 0, 0, 13, 13, 2
.byte 2, 2, 8, 7, 8, 0, 0, 1, 8, 18, 7, 17, 7, 7
.res 2, 0

objSec:
.byte 0, 0, 7, 47, 6, 3, 48, 11, 12, 12, 50, 50, 14, 10, 50, 50
.byte 50, 10, 14, 14, 4, 34, 13, 24, 22, 20, 35, 36, 49, 40, 44, 44
.byte 40, 45, 46, 30, 37, 31, 29, 24, 18, 10, 14, 37, 1, 27
.res 2, 0

; vertex data
vertX:
.byte -12, -7, -1, -18, -18, -1, -13, -6, -8, -2, -26, -26, -8, -2, -17, -20
.byte -17, -20, -17, -17, -26, -26, 1, 6, 6, 1, 12, 12, 12, 33, 40, 33
.byte -2, -2, -37, -37, -37, -44, -58, -63, -63, -58, -44, -37, -56, -45, -45, -56
.byte -56, -46, -46, -56, -52, -52, -44, -52, -52, -44, 9, 40, 23, 14, 14, 22
.byte 31, 31, 23, 21, 21, -28, -28, -46, -46, 0, 12, 12, 0, 31, 31, 47
.byte 47, 50, 50, 55, 55, 50, 50, 47, 47, 50, 63, 63, 7, 7, 5, 24
.byte 30, 27, 33, 57, 57, 5, -8, -5, 0, -5, 0, -2, 0, 35, 35, 40
.byte 40, 15, -13, -20, -17, -5, -9, -9, 0, 0, 13, 14, -


         getDiffusivity(betanp1, new_time, first_spec, 0, NUM_SPECIES);  // species
         getDiffusivity(betanp1, new_time, Temp, NUM_SPECIES, 1);        // temperature (lambda)
         compute_enthalpy_fluxes(GammaKp1,betanp1,new_time);             // Compute F[N+1] = sum_m (H_m Gamma_m),
                                                                          //         F[N+2] = - lambda grad T

         // Note: DT (comp 1) and DD (comp 0) are in the same multifab
         MultiFab DiffTerms_pre(grids,dmap,2,0,MFInfo(),Factory());
         // No redistribution for those.
         flux_divergence(DiffTerms_pre,0,GammaKp1,NUM_SPECIES+1,2,-1);

         // Diffuse species sync to get dGamma^{sync}, then form Gamma^{postsync} = Gamma^{presync} + dGamma^{sync}
         // Before this call Ssync = \nabla \cdot \delta F_{rhoY} - \delta_ADV - Y^{n+1,p}\delta rho^{sync}
         bool include_deltaWbar = true;
         differential_spec_diffuse_sync(dt, include_deltaWbar, last_mac_sync_iter);
         // Ssync for species now contains rho^{n+1}(delta_Y)^sync

         for (int d=0; d<AMREX_SPACEDIM; ++d) {
            MultiFab::Add(*SpecDiffusionFluxnp1[d],*GammaKp1[d],0,0,NUM_SPECIES,0);
         }

         //
         // For all species increment sync by (sync_for_rho)*Y_presync.
         // Before this, Ssync holds rho^{n+1} (delta Y)^sync
         // DeltaYsync holds Y^{n+1,p} * (delta rho)^sync
         // Remove DdWar if req. as it has been added both to the RHS of the diffsync solve and to the fluxes afterward.
#ifdef AMREX_USE_OMP
#pragma omp parallel if (Gpu::notInLaunchRegion())
#endif
         for (MFIter mfi(S_new, TilingIfNotGPU()); mfi.isValid(); ++mfi)
         {
            const Box& bx = mfi.tilebox();
            auto const& rhoYnew    = S_new.array(mfi,first_spec);
            auto const& rhoYssync  = Ssync.array(mfi,first_spec-AMREX_SPACEDIM);
            auto const& drhoYsync  = DeltaYsync.const_array(mfi,0);
            auto const& dWbarsync  = (use_wbar) ? DdWbar.const_array(mfi) : DeltaYsync.const_array(mfi);
            amrex::ParallelFor(bx, NUM_SPECIES, [rhoYnew,rhoYssync,drhoYsync,
                                                 dWbarsync,use_wbar=use_wbar]
            AMREX_GPU_DEVICE (int i, int j, int k, int n) noexcept
            {
                rhoYssync(i,j,k,n) += drhoYsync(i,j,k,n);
                if (use_wbar) rhoYssync(i,j,k,n) -= dWbarsync(i,j,k,n);
                rhoYnew(i,j,k,n) += rhoYssync(i,j,k,n);
            });
         }

         if (use_wbar) {
            // compute (overwrite) beta grad Wbar terms using the post-sync state
            MultiFab scalars_alias(S_new, amrex::make_alias, Density, NUM_SPECIES+1);
            compute_Wbar_fluxes(scalars_alias, new_time, 0, 1.0);
         }


rd = properties.getProperty("keyPassword")
        }
    }

    buildTypes {
        all {
            signingConfig = config ?: signingConfigs["debug"]
        }

        release {
            isMinifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"
            )
        }
    }

    buildFeatures {
        prefab = true
    }

    externalNativeBuild.ndkBuild {
        path("src/main/cpp/Android.mk")
    }

    androidResources.additionalParameters += listOf(
        "--allow-reserved-package-id",
        "--package-id",
        "0x64"
    )

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }

    kotlinOptions {
        jvmTarget = JavaVersion.VERSION_17.toString()
    }

    dependenciesInfo {
        includeInApk = false
    }
}

dependencies {
    compileOnly(libs.legacy.xposed.api)
    implementation(libs.androidx.documentfile)
    implementation(libs.androidx.recyclerview)
    implementation(libs.dexkit)
    implementation(libs.ezxhelper)
    implementation(libs.mmkv)
    implementation(libs.ndk.cxx)
    implementation(libs.ndk.nativehelper)
}

val adbExecutable: String = androidComponents.sdkComponents.adb.get().asFile.absolutePath

val restartTwitter = task("restartTwitter").doLast {
    Runtime.getRuntime().let {
        it.exec("$adbExecutable shell am force-stop com.twitter.android").waitFor()
        it.exec("$adbExecutable shell am start $(pm resolve-activity --components com.twitter.android)")
            .waitFor()
    }
}

afterEvaluate {
    tasks.named("installDebug") {
        finalizedBy(restartTwitter)
    }
    tasks.named("installRelease") {
        finalizedBy(restartTwitter)
    }
}
package icu.nullptr.twifucker.hook

import com.github.kyuubiran.ezxhelper.ClassUtils.loadClass
import com.github.kyuubiran.ezxhelper.HookFactory.`-Static`.createHook
import com.github.kyuubiran.ezxhelper.Log
import com.github.kyuubiran.ezxhelper.finders.FieldFinder
import com.github.kyuubiran.ezxhelper.finders.MethodFinder
import icu.nullptr.twifucker.afterMeasure
import icu.nullptr.twifucker.modulePrefs

object JsonTimelineTweetHook : BaseHook() {
    override val name: String
        get() = "JsonTimelineTweetHook"

    override fun init() {
        if (!modulePrefs.getBoolean("disable_promoted_content", true)) return

        val jsonTimelineTweetClass =
            loadClass("com.twitter.model.json.timeline.urt.JsonTimelineTweet")
        val jsonTimelineTweetMapperClass =
            loadClass("com.twitter.model.json.timeline.urt.JsonTimelineTweet\$\$JsonObjectMapper")

        val jsonTweetResultsClass =
            FieldFinder.fromClass(loadClass("com.twitter.model.json.core.JsonTweetResults"))
                .first().type
        val jsonTweetResultsField =
            FieldFinder.fromClass(jsonTimelineTweetClass).filterByType(jsonTweetResultsClass)
                .first()
        val jsonTweetIdField =
            FieldFinder.fromClass(jsonTimelineTweetClass).filterByType(String::class.java).first()

        val jsonPromotedContentUrtClass =
            loadClass("com.twitter.model.json.timeline.urt.JsonPromotedContentUrt")
        val jsonPromotedContentUrtField =
            FieldFinder.fromClass(jsonTimelineTweetClass).filterByType(jsonPromotedContentUrtClass)
                .first()

        MethodFinder.fromClass(json


                 ConnectButton.interactable = false;
                    CreateSubSceneButton.interactable = true;
                    SendMessageButton.interactable = true;
                    CreaateAddressabeButton.interactable = true;
                    SendAddressableButton.interactable = true;
                    Log.Debug("连接到服务器完成");
                    _session.AddComponent<SessionHeartbeatComponent>().Start(2000);
               },
               () =>
               {
                    ConnectButton.interactable = true;
                    CreateSubSceneButton.interactable = false;
                    SendMessageButton.interactable = false;
                    CreaateAddressabeButton.interactable = false;
                    SendAddressableButton.interactable = false;
                    Log.Error("无法连接到目标服务器");
               },
               () =>
               {
                    ConnectButton.interactable = false;
                    CreateSubSceneButton.interactable = false;
                    SendMessageButton.interactable = false;
                    CreaateAddressabeButton.interactable = false;
                    SendAddressableButton.interactable = false;
                    Log.Debug("与服务器断开了连接");
               },
               false, 5000);
     }

     private async FTask CreateSubScene()
     {
          var response = (G2C_CreateSubSceneResponse)await _session.Call(new C2G_CreateSubSceneRequest());
          if (response.ErrorCode != 0)
          {
               Log.Debug($"创建SubScene失败 ErrorCode: {response.ErrorCode}");
                return;
          }
          Log.Debug("创建子场景成功");
     }

     private void SendMessage()
     {
          _session.Send(new C2G_SendToSubSceneMessage());
     }

     private async FTask CreateAddressable()
     {
          var response = (G2C_CreateSubSceneAddressableResponse)await _session.Call(new C2G_CreateSubSceneAddressableRequest());
          if (response.ErrorCode != 0)
          {
               Log.Debug($"创建SubSceneAddressable失败 ErrorCode: {response.ErrorCode}");
               return;
          }

          DisposeAddressableButton.interactable = true;
          Log.Debug("创建SubSceneAddressable成功");
     }

     private void SendAddressable()
     {
          _session.Send(new C2SubScene_TestMessage()
          {
               Tag = "hi subScene Addressable"
          });
     }

     private void DisposeScene()
     {
          _session.Send(new C2SubScene_TestDisposeMessage());
     }
}


-serif;
  --ff-serif: Charter, 'Bitstream Charter', 'Sitka Text', Cambria, serif;
  --ff-mono: 'Nimbus Mono PS', 'Courier New', monospace;
  --ff-cursive: 'Segoe Print', 'Bradley Hand', Chilanka, TSCu_Comic, casual, cursive;
  --ff-fantasy: 'Party Let', fantasy;
  --indent-1: 1em;
  --indent-2: 1.5em;
  --indent-3: 2em;
  --tw: 60ch;
  --tw-wide: 75ch;
  --tw-narrow: 50ch;
  --ls-tracked: 0.1em;
  --ls-tight: -0.05em;
  --ls-mega: 0.25em;
  --ls-none: normal;
  --lh-solid: 1;
  --lh-title: 1.25;
  --lh-copy: 1.5;
}

/*
 * Reset Styles
 *
 * This is adapted from https://github.com/sindresorhus/modern-normalize but some things were omitted.
 *
 * Namely, anything that appeared to be a design choice, or that didn't seem to actually apply
 * to baesline browsers any longer.
 * @category reset
 */

/* Reset styles aren't classes to be used. Comments here explain why these are the way they are.
 * @group reset
 */

/* `border-box` is generally agreed to be a better default box model. */

*,
::before,
::after {
	box-sizing: border-box;
}

/* When orientation changes on iOS, font sizing can get messed up. Allegedly. */

html {
	-webkit-text-size-adjust: 100%;
}

/* In general, we don't want margins by default as this is rarely desired and can create confusion
 * before you have started applying styles.
 */

body {
	margin: 0;
}

/* Safari and Chrome do not use the ideal font weight for `b` or `strong` elements. */

b, strong {
	font-weight: bolder;
}

/* Browsers can show a smaller font size for code, pre, etc., which is not usually desired.  This
 * tries to make the font size of these elements match the surrounding font size. */

code, kbd, samp, pre {
  font-size: 1em;
}

/* Attempt to prevent `sub` and `sup` from affect the line-height in browsers. */

sub,
sup {
	font-size: 75%;
	line-height: 0;
	position: relative;
	vertical-align: baseline;
}

sub {
	bottom: -0.25em;
}

sup {
	top: -0.5em;
}

/* Attempt to get form elements to use the font chosen on the page and not the sytstem
 * font.  Further, removing margins that some browser may have set, so that behavior is consistent
 * and predictable before styling has been applied
 */

button,
input,
optgroup,
select,
textarea {
	font-family: inherit;
	margin: 0;
}

/* Attempt to get Mobile Safari to render unstyled buttons in a way that looks
 * like a button, despite all efforst by Alan Dye to the contrary.
 *
 * Note that this uses "input" explicitly, because this is targeting inputs,
 * not just any element using the type attribute.
 */

button,
input[type='button'],
input[type='reset'],
input[type='submit'] {
	-webkit-appearance: button;
}

/* Attempt to create predictable spacing for `legend` elements, in case the stars
 * have aligned and someone is using them. */

legend {
	padding: 0;
}

/* Chrome and Firefox can use the wrong a


/>
 *  p5.Env: An Envelope is a series
 *    of fades over time. Often used to control an object's
 *    output gain level as an "ADSR Envelope" (Attack, Decay,
 *    Sustain, Release). Can also modulate other parameters.

 *  p5.Delay: A delay effect with
 *    parameters for feedback, delayTime, and lowpass filter.

 *  p5.Filter: Filter the frequency range of a
 *    sound.
 *

 *  p5.Reverb: Add reverb to a sound by specifying
 *    duration and decay.

 *  p5.Convolver: Extends
 *  p5.Reverb to simulate the sound of real
 *    physical spaces through convolution.

 *  p5.SoundRecorder: Record sound for playback
 *    / save the .wav file.
 *  p5.Phrase, p5.Part and
 *  p5.Score: Compose musical sequences.
 *

 *  p5.sound is on GitHub.
 *  Download the latest version
 *  here.
 *
 *  @module p5.sound
 *  @submodule p5.sound
 *  @for p5.sound
 *  @main
 */
/**
 *  p5.sound developed by Jason Sigal for the Processing Foundation, Google Summer of Code 2014. The MIT License (MIT).
 *
 *  http://github.com/therewasaguy/p5.sound
 *
 *  Some of the many audio libraries & resources that inspire p5.sound:
 *   - TONE.js (c) Yotam Mann, 2014. Licensed under The MIT License (MIT). https://github.com/TONEnoTONE/Tone.js
 *   - buzz.js (c) Jay Salvat, 2013. Licensed under The MIT License (MIT). http://buzz.jaysalvat.com/
 *   - Boris Smus Web Audio API book, 2013. Licensed under the Apache License http://www.apache.org/licenses/LICENSE-2.0
 *   - wavesurfer.js https://github.com/katspaugh/wavesurfer.js
 *   - Web Audio Components by Jordan Santell https://github.com/web-audio-components
 *   - Wilm Thoben's Sound library for Processing https://github.com/processing/processing/tree/master/java/libraries/sound
 *
 *   Web Audio API: http://w3.org/TR/webaudio/
 */
var sndcore;
sndcore = function () {
  'use strict';
  /* AudioContext Monkeypatch
     Copyright 2013 Chris Wilson
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at
         http://www.apache.org/licenses/LICENSE-2.0
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
  */
  (function (global, exports, perf) {
    exports = exports || {};
    'use strict';
    function fixSetTarget(param) {
      if (!param)
        // if NYI, just return
        return;
      if (!param.setTargetAtTime)
        param.setTargetAtTime = param.setTargetValueAtTime;
    }
    if (window.hasOwnProperty('webkitAudioContext') && !window.hasOwnProperty('AudioContext')) {
      window.AudioContext = webkitAudioContext;
      if (!AudioContext.prototype.has


nction is called every fixed framerate frame, if the MonoBehaviour is enabled.
  /// </summary>
  void FixedUpdate()  {
    data = BuildData();
  }

  internal static unsafe void TestPoolCollisions(DanmakuPool pool) {
    var layersPtr = (int*)(pool.CollisionMasks.GetUnsafePtr());
    var count = pool.ActiveCount;
    for (var i = 0; i < count; i++) {
      if (*layersPtr++ == 0) continue;
      var layerMask = pool.CollisionMasks[i];
      var oldPosition = pool.OldPositions[i];
      var direction = pool.Positions[i] - oldPosition;
      var distance = direction.magnitude;
      var hits = Physics2D.CircleCastNonAlloc(oldPosition, pool.ColliderRadius, direction, raycastCache, distance, layerMask);
      if (hits <= 0) continue;
      var danmaku = new Danmaku(pool, i);
      for (var j = 0; j < hits; j++) {
        var collider = raycastCache[j].collider;
        List<DanmakuCollider> danmakuColliders;
        if (!ColliderMap.TryGetValue(collider, out danmakuColliders)) continue;
        var collision = new DanmakuCollision {
          Danmaku = danmaku,
          RaycastHit = raycastCache[j]
        };
        foreach (var dCollider in danmakuColliders) {
          if (dCollider != null && dCollider.isActiveAndEnabled) {
            dCollider.AddDanmaku(collision);
          }
        }
      }
    }
  }

  internal static void FlushAll() {
    foreach (var collider in Colliders) {
      collider.Flush();
    }
  }

  internal void AddDanmaku(DanmakuCollision danmaku) => collidedDanmaku.Add(danmaku);
  internal void Flush() {
    if (collidedDanmaku.Count > 0 && OnDanmakuCollision != null) {
      OnDanmakuCollision(collidedDanmaku.AsReadOnly());
    }
    collidedDanmaku.Clear();
  }

  internal static int TestCollisions(Bounds2D bounds)  {
    if (!GlobalBounds.Intersects(bounds)) return 0;
    int collisions = 0;
    for (var i = 0; i < HighestLayer; i++) {
      var mask = 1 << i;
      if ((GlobalLayerMask & mask) == 0) continue;
      var layerColliders = Data[i];
      for (var j = 0; j < layerColliders.Count; j++) {
        if (!layerColliders[j].Intersects(bounds)) continue;
        collisions |= mask;
        break;
      }
    }
    return collisions;
  }

  ColliderData BuildData() {
    Bounds2D? bounds = null;
    foreach (var collider in colliders) {
      if (collider != null && collider.enabled && collider.gameObject.activeInHierarchy) {
        if (bounds == null) {
          bounds = collider.bounds;
        } else {
          bounds.Value.Encapsulate(collider.bounds);
        }
      }
    }
    var fullBounds = bounds ?? new Bounds2D(transform.position, Vector3.zero);
    return new ColliderData {
      Bounds = fullBounds,
      LayerMask = 1 << gameObject.layer
    };
  }

}

}


              |
| `pre-rollback`   | 在模板渲染之后，资源回滚之前，执行一个回滚请求                                                            |
| `post-rollback`  | 在所有资源被修改之后执行一个回滚请求                                                                     |
| `test`           | 调用Helm test子命令时执行 ([test文档](https://helm.sh/zh/docs/topics/chart_tests/))                     |

_注意`crd-install`钩子已被移除以支持Helm 3的`crds/`目录。_

## 钩子和发布生命周期

钩子允许你在发布生命周期的关键节点上有机会执行操作。比如，考虑`helm install`的生命周期。默认的，生命周期看起来是这样：

1. 用户执行`helm install foo`
2. Helm库调用安装API
3. 在一些验证之后，库会渲染`foo`模板
4. 库会加载结果资源到Kubernetes
5. 库会返回发布对象（和其他数据）给客户端
6. 客户端退出

Helm 为`install`周期定义了两个钩子：`pre-install`和`post-install`。如果`foo` chart的开发者两个钩子都执行，
周期会被修改为这样：

1. 用户返回 `helm install foo`
2. Helm库调用安装API
3. 在 `crds/`目录中的CRD会被安装
4. 在一些验证之后，库会渲染`foo`模板
5. 库准备执行`pre-install`钩子(将hook资源加载到Kubernetes中)
6. 库按照权重对钩子排序(默认将权重指定为0)，然后在资源种类排序，最后按名称正序排列。
7. 库先加载最小权重的钩子(从负到正)
8. 库会等到钩子是 "Ready"状态(CRD除外)
9. 库将生成的资源加载到Kubernetes中。注意如果设置了`--wait`参数，库会等所有资源是ready状态，
   且所有资源准备就绪后才会执行`post-install`钩子。
10. 库执行`post-install`钩子(加载钩子资源)。
11. 库会等到钩子是"Ready"状态
12. 库会返回发布对象(和其他数据)给客户端
13. 客户端退出

  等钩子准备好是什么意思？ 这取决于钩子声明的资源。如果资源是 `Job` 或 `Pod`类型，Helm会等到直到他成功运行完成。
如果钩子失败，发布就会失败。这是一个 _阻塞操作_,所以Helm客户端会在这个任务执行时暂停。

  针对其他种类，一旦Kubernetes将资源标记为已加载(已添加或已更新)，资源会被认为是"Ready"。 当一个钩子中声明了很多资源时，
资源会串行执行。如果有钩子权重，会按照权重顺序执行。从Helm 3.2.0开始，具有相同权重的钩子资源会和普通非钩子资源以相同的顺序安装。
否则，顺序就无法保证。（Helm 2.3.0及之后，它们按照字母排序。不过该行为并不会绑定，将来可能会改变。）增加钩子权重被认为是很好的做法，
如果权重不重要，可以设置为`0`。

### 钩子资源不使用对应版本管理

钩子创建的资源无法作为


       public static void SetupFileToClean(this Mock<IFileCleaner> fileCleaner, string input, string output) =>
                fileCleaner.Setup(x => x.Clean(input, It.IsAny<LegacySettings>(), It.IsAny<CancellationToken>()))
                    .Returns(output);

            public static void VerifyFileCleaned(this Mock<IFileCleaner> fileCleaner, string expectedContent) =>
                fileCleaner.Verify(x => x.Clean(expectedContent,
                    It.IsAny<LegacySettings>(),
                    It.IsAny<CancellationToken>()), Times.Once);

            public static void AddFile(this Mock<IVsAwareFileSystem> fileSystem, string filePath, string content) =>
                fileSystem.Setup(x => x.LoadAsTextAsync(filePath)).Returns(Task.FromResult(content));

            public static void VerifyFileLoaded(this Mock<IVsAwareFileSystem> fileSystem, string filePath) => fileSystem.Verify(x => x.LoadAsTextAsync(filePath), Times.Once);

            public static void VerifyFileSaved(this Mock<IVsAwareFileSystem> fileSystem, string filePath, string content) => fileSystem.Verify(x => x.SaveAsync(filePath, content), Times.Once);

            public static void VerifyFileNotSaved(this Mock<IVsAwareFileSystem> fileSystem, string filePath) => fileSystem.Verify(x => x.SaveAsync(filePath, It.IsAny<string>()), Times.Never);

            public static void VerifyNoFilesSaved(this Mock<IVsAwareFileSystem> fileSystem) => fileSystem.Verify(x => x.SaveAsync(It.IsAny<string>(), It.IsAny<string>()), Times.Never);

            public static void VerifyDirectoryDeleted(this Mock<IVsAwareFileSystem> fileSystem, string folderPath) => fileSystem.Verify(x => x.DeleteFolderAsync(folderPath), Times.Once);
        }
    }
}


total - group = solo, no need to keep track separately
    end
end

function addon.tracker:PLAYER_DEAD()
    if addon.tracker.db.profile["levels"][addon.tracker.playerLevel].deaths then
        addon.tracker.db.profile["levels"][addon.tracker.playerLevel].deaths =
            addon.tracker.db.profile["levels"][addon.tracker.playerLevel].deaths +
                1
    else
        addon.tracker.db.profile["levels"][addon.tracker.playerLevel].deaths = 1
    end
end

function addon.tracker:PLAYER_ENTERING_WORLD()
    addon.tracker.waitingForTimePlayed = {
        event = 'PLAYER_ENTERING_WORLD',
        date = C_DateAndTime.GetCurrentCalendarTime()
    }

    RequestTimePlayed()
end

function addon.tracker.UpdateReportLevels(levelData, playerLevel, target,
                                          attachment)

    local trackerUi = addon.tracker.ui[attachment:GetName()]

    if addon.tracker.state.reportLevelMenu then
        EasyMenu(addon.tracker.state.reportLevelMenu, trackerUi.levelMenuFrame,
                 trackerUi.levelButton.frame, 0, 0, "MENU")
        return
    end

    local sparse = {}
    local insertData, parentIndex, lowerLevel, upperLevel

    for level, _ in pairs(levelData) do
        parentIndex = floor(level / 10) + 1
        lowerLevel = mmax(floor(level / 10) * 10, 1) -- Handle 0 to 10 phrasing
        upperLevel = floor(level / 10) * 10 + 10

        if not sparse[parentIndex] then
            sparse[parentIndex] = {
                text = fmt(L("%d to %d"), lowerLevel, upperLevel),
                hasArrow = true,
                menuList = {}
            }
        end

        if level > playerLevel then break end

        insertData = {
            notCheckable = 1,
            func = function(_, l, text)
                addon.tracker:UpdateReport(l, target, attachment)

                trackerUi.levelButton:SetText(text)
                _G.CloseDropDownMenus()
            end
        }

        if level == addon.tracker.maxLevel then
            insertData.text = fmt("%d (%s)", level, L("Max"))
        else
            insertData.text = fmt(L("%d to %d"), level, level + 1)
        end

        insertData.arg1 = level
        insertData.arg2 = insertData.text

        tinsert(sparse[parentIndex].menuList, insertData)

        table.sort(sparse[parentIndex].menuList,
                   function(k1, k2) return k1.arg1 < k2.arg1 end)
    end

    local menu = {}

    -- Shrink sparse array, e.g. missing data
    for _, d in pairs(sparse) do tinsert(menu, d) end

    addon.tracker.state.reportLevelMenu = menu
    EasyMenu(menu, trackerUi.levelMenuFrame, trackerUi.levelButton.frame, 0, 0,
             "MENU")
end

local function buildSpacer(height)
    local spacer = AceGUI:Create("SimpleGroup")
    spacer:SetLayout("Fill")
    spacer:SetHeight(height)
    spacer:SetWidth(30)
    spacer:SetFullWidth(true)

    return spacer
end

function addon.tracker:CreateGui(attachment, target)
    if not attachment then return end
    local attachmentName = attachment.GetName and attachment:GetName()
    if not attachmentName then return end
    if addon.tracker.ui[attachmentName] then return end

    local offset = {
        x = -38,
        y = -32,
        tabsHeight = _G.CharacterFrameTab1:GetHeight()
    }
    local padding = 4
    local levelData, playerLevel

    addon.tracker.ui[attachmentName] = AceGUI:Create("Frame")
    local trackerUi = addon.tracker.ui[attachmentName]

    tr


(DrawUi::new(&loader, &mesh_storage)),
        )
    };
    game = game.with_local(RenderSystem::build(pipe, Some(config))?);
    Ok(game.build()?.run())
}

fn main() {
    if let Err(e) = run() {
        println!("Failed to execute example: {}", e);
        ::std::process::exit(1);
    }
}

fn gen_sphere(u: usize, v: usize) -> Vec<PosNormTex> {
    SphereUV::new(u, v)
        .vertex(|(x, y, z)| {
            PosNormTex {
                position: [x, y, z],
                normal: Vector3::from([x, y, z]).normalize().into(),
                tex_coord: [0.1, 0.1],
            }
        })
        .triangulate()
        .vertices()
        .collect()
}

/// This function initialises a sphere and adds it to the world.
fn initialise_sphere(world: &mut World) {
    // Create a sphere mesh and material.

    use amethyst::assets::Handle;
    use amethyst::renderer::{Material, MaterialDefaults};

    let (mesh, material) = {
        let loader = world.read_resource::<Loader>();

        let mesh: Handle<Mesh> =
            loader.load_from_data(gen_sphere(32, 32).into(), (), &world.read_resource());

        let albedo = SPHERE_COLOUR.into();

        let tex_storage = world.read_resource();
        let mat_defaults = world.read_resource::<MaterialDefaults>();

        let albedo = loader.load_from_data(albedo, (), &tex_storage);

        let mat = Material {
            albedo,
            ..mat_defaults.0.clone()
        };

        (mesh, mat)
    };

    // Create a sphere entity using the mesh and the material.
    world
        .create_entity()
        .with(Transform::default())
        .with(mesh)
        .with(material)
        .build();
}

/// This function adds an ambient light and a point light to the world.
fn initialise_lights(world: &mut World) {
    // Add ambient light.
    world.add_resource(AmbientColor(AMBIENT_LIGHT_COLOUR));

    let light: Light = PointLight {
        center: LIGHT_POSITION.into(),
        radius: LIGHT_RADIUS,
        intensity: LIGHT_INTENSITY,
        color: POINT_LIGHT_COLOUR,
        ..Default::default()
    }.into();

    // Add point light.
    world.create_entity().with(light).build();
}

/// This function initialises a camera and adds it to the world.
fn initialise_camera(world: &mut World) {
    let (width, height) = {
        let dim = world.read_resource::<ScreenDimensions>();
        (dim.width(), dim.height())
    };
    world.add_resource(Camera::standard_3d(width, height));
}
use proc_macro::TokenStream;
use quote::quote;
use syn::{
    parse::{Parse, ParseStream},
    parse_macro_input,
    spanned::Spanned,
    FnArg, Ident, ImplItemMethod, Pat, Type,
};

type Res<T> = syn::parse::Result<T>;

pub fn wrapped_tramp(attr: TokenStream, item: TokenStream) -> TokenStream {
    let TrampArgs { wrapper } = parse_macro_input!(attr as TrampArgs);
    let meth: ImplItemMethod = parse_macro_input!(item as ImplItemMethod);
    crate::error::wrap(wrapped_tramp_with_type(wrapper, meth))
}

pub fn defer_tramp(attr: TokenStream, item: TokenStream) -> TokenStream {
    let TrampArgs { wrapper } = parse_macro_input!(attr as TrampArgs);
    let meth: ImplItemMethod = parse_macro_input!(item as ImplItemMethod);
    crate::error::wrap(wrapped_defer_tramp_with_type(wrapper, meth))
}

pub fn wrapped_sel_list_tramp(attr: TokenStream, item: TokenStream) -> TokenStream {
    let TrampArgs { wrapper


 substs = tcx.mk_substs(::std::iter::once(ty::subst::GenericArg::from(ret_ty)));
    Operand::function_handle(tcx, fn_def_id, substs, span)
}

fn placeholder_block(span: Span, scope: SourceScope, is_cleanup: bool) -> BasicBlockData<'tcx> {
    BasicBlockData {
        statements: vec![],
        terminator: Some(Terminator {
            source_info: SourceInfo { span, scope },
            // this gets overwritten by the counter Call
            kind: TerminatorKind::Unreachable,
        }),
        is_cleanup,
    }
}

fn hir_body<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> &'tcx rustc_hir::Body<'tcx> {
    let hir_node = tcx.hir().get_if_local(def_id).expect("DefId is local");
    let fn_body_id = hir::map::associated_body(hir_node).expect("HIR node is a function with body");
    tcx.hir().body(fn_body_id)
}

fn hash_mir_source<'tcx>(tcx: TyCtxt<'tcx>, hir_body: &'tcx rustc_hir::Body<'tcx>) -> u64 {
    let mut hcx = tcx.create_no_span_stable_hashing_context();
    hash(&mut hcx, &hir_body.value).to_smaller_hash()
}

fn hash(
    hcx: &mut StableHashingContext<'tcx>,
    node: &impl HashStable<StableHashingContext<'tcx>>,
) -> Fingerprint {
    let mut stable_hasher = StableHasher::new();
    node.hash_stable(hcx, &mut stable_hasher);
    stable_hasher.finish()
}
extern crate ordered_float;
#[macro_use]
extern crate polyhorn_yoga as yoga;

use yoga::{Align, Direction, Display, FlexDirection, Node, Undefined};
use yoga::prelude::*;

#[test]
fn test_dirty_propagation() {
	let mut root = Node::new();

	style!(root,
		AlignItems(Align::FlexStart),
		Width(100 pt),
		Height(100 pt)
	);

	let mut root_child_0 = Node::new();

	style!(root_child_0,
		Width(50 pt),
		Height(20 pt)
	);

	let mut root_child_1 = Node::new();

	style!(root_child_1,
		Width(50 pt),
		Height(20 pt)
	);

	root.insert_child(&mut root_child_0, 0);
	root.insert_child(&mut root_child_1, 1);
	root.calculate_layout(Undefined, Undefined, Direction::LTR);

	style!(root_child_0,
		Width(20 pt)
	);

	assert!(root_child_0.is_dirty());
	assert!(!root_child_1.is_dirty());
	assert!(root.is_dirty());

	root.calculate_layout(Undefined, Undefined, Direction::LTR);

	assert!(!root_child_0.is_dirty());
	assert!(!root_child_1.is_dirty());
	assert!(!root.is_dirty());
}

#[test]
fn test_dirty_propagation_only_if_prop_changed() {
	let mut root = Node::new();

	style!(root,
		AlignItems(Align::FlexStart),
		Width(100 pt),
		Height(100 pt)
	);

	let mut root_child_0 = Node::new();

	style!(root_child_0,
		Width(50 pt),
		Height(20 pt)
	);

	let mut root_ch


/*****************************************************************************\
  Mode9.h : Interface for the Mode9 class

  Copyright (c) 1996 - 2015, HP Co.
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:
  1. Redistributions of source code must retain the above copyright
     notice, this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
  3. Neither the name of HP nor the names of its
     contributors may be used to endorse or promote products derived
     from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
  NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  TO, PATENT INFRINGEMENT; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\*****************************************************************************/

#ifndef MODE9_H
#define MODE9_H

#include "CommonDefinitions.h"
#include "Processor.h"
#include "Compressor.h"

class Mode9 : public Compressor
{
public:
    Mode9(unsigned int RasterSize, bool bPackedBits = true);
    virtual ~Mode9();
    bool Process(RASTERDATA* input);
    bool NextOutputRaster (RASTERDATA& next_raster);
    void Flush();
    bool ResetSeedRow;
	bool m_bPackedBits;
}; // Mode9

#endif // MODE9_H


          letterSpacing: -5,
              shadows: [
                Shadow(
                  offset: Offset(0, 4), // y축으로 4의 offset
                  blurRadius: 4, // blur 정도
                  color: Colors.black.withOpacity(0.25), // 25% 투명도의 검정색
                ),
              ],
            ),
          ),
        );
      }),
    );
  }
}

// class _authgoogle extends StatelessWidget {
//   const _authgoogle({super.key});
//
//   static const String _url = 'http://copet.life/auth/google';
//
//   Future<void> _launchURL(BuildContext context) async {
//     final response = await AuthGoogle.authGoogle();
//     final cookies = response.headers['set-cookie']?[0];
//     // 회원 가입 여부 확인
//     bool isRegistered = await checkRegistration(cookies);
//     print('___________________________________Received headers: $cookies');
//     if (isRegistered) {
//       // 회원 가입된 경우 페이지 이동
//       Navigator.push(
//           context, MaterialPageRoute(builder: (context) => mainhome()));
//     } else {
//       // 회원 가입되지 않은 경우 다른 페이지로 이동 또는 회원 가입 화면 표시
//       Navigator.push(
//           context, MaterialPageRoute(builder: (context) => logintype()));
//     }
//   }
//
//   Future<bool> checkRegistration(String? cookies) async {
//     // 쿠키를 서버로 전송하여 회원 가입 여부 확인
//     // 서버에서는 쿠키를 이용하여 회원 가입 여부를 확인하고 응답을 반환합니다.
//     // 이 예시에서는 간단히 회원 가입 여부를 확인하도록 구현합니다.
//     if (cookies != null && cookies.contains('userId')) {
//       return true; // 회원 가입된 경우
//     } else {
//       return false; // 회원 가입되지 않은 경우
//     }
//   }
//
//   @override
//   Widget build(BuildContext context) {
//     return Container(
//       width: 300, // 너비 설정
//       height: 45, // 높이 설정
//       child: ElevatedButton(
//         onPressed: () async {
//           await _launchURL(context);
//         },
//         child: Row(
//           mainAxisAlignment: MainAxisAlignment.spaceBetween,
//           children: [
//             Image.asset(
//               'asset/img/login/googleicon.png', // PNG 아이콘 경로
//               width: 25,
//               height: 25,
//             ),
//             Text(
//               '구글 로그인',
//               style: TextStyle(
//                 color: Colors.black,
//                 fontWeight: FontWeight.bold,
//               ),
//             ),
//             const SizedBox(width: 25),
//           ],
//         ),
//         style: ElevatedButton.styleFrom(
//             backgroundColor: Color(0xFFF8F8F8),
//             minimumSize: Size(double.infinity, 45), // 버튼의 최소 크기 설정
//             shape: RoundedRectangleBorder(
//               borderRadius: BorderRadius.circular(10),
//             )),


                auto pDeviceSettings = GetDXUTState().GetCurrentDeviceSettings();
                if( FAILED( DXUTChangeDevice( pDeviceSettings, false ) ) )
                {
                    DXUTShutdown();
                    return;
                }

                // How to handle display orientation changes in full-screen mode?
            }
        }
    }
    else if( DXGI_ERROR_DEVICE_REMOVED == hr )
    {
        // Use a callback to ask the app if it would like to find a new device.
        // If no device removed callback is set, then look for a new device
        if( FAILED( DXUTHandleDeviceRemoved() ) )
        {
            // Perhaps get more information from pD3DDevice->GetDeviceRemovedReason()?
            DXUTDisplayErrorMessage( DXUTERR_DEVICEREMOVED );
            DXUTShutdown();
            return;
        }
    }
    else if( SUCCEEDED( hr ) )
    {
        if( GetDXUTState().GetRenderingOccluded() )
        {
            // Now that we're no longer occluded
            // allow us to render again
            GetDXUTState().SetRenderingOccluded( false );
        }
    }

    // Update current frame #
    int nFrame = GetDXUTState().GetCurrentFrameNumber();
    nFrame++;
    GetDXUTState().SetCurrentFrameNumber( nFrame );

    // Check to see if the app should shutdown due to cmdline
    if( GetDXUTState().GetOverrideQuitAfterFrame() != 0 )
    {
        if( nFrame > GetDXUTState().GetOverrideQuitAfterFrame() )
            DXUTShutdown();
    }

    return;
}

//--------------------------------------------------------------------------------------
// Cleans up the 3D environment by:
//      - Calls the device lost callback
//      - Calls the device destroyed callback
//      - Releases the D3D device
//--------------------------------------------------------------------------------------
void DXUTCleanup3DEnvironment( _In_ bool bReleaseSettings )
{
    auto pd3dDevice = DXUTGetD3D11Device();

    if( pd3dDevice )
    {
        if (GetDXUTState().GetD3D11RasterizerState())
            GetDXUTState().GetD3D11RasterizerState()->Release();

        // Call the app's SwapChain lost callback
        GetDXUTState().SetInsideDeviceCallback( true );
        if( GetDXUTState().GetDeviceObjectsReset() )
        {
            LPDXUTCALLBACKD3D11SWAPCHAINRELEASING pCallbackSwapChainReleasing =
                GetDXUTState().GetD3D11SwapChainReleasingFunc();
            if( pCallbackSwapChainReleasing )
                pCallbackSwapChainReleasing( GetDXUTState().GetD3D11SwapChainReleasingFuncUserContext() );
            GetDXUTState().SetDeviceObjectsReset( false );
        }

        // Release our old depth stencil texture and view
        auto pDS = GetDXUTState().GetD3D11DepthStencil();
        SAFE_RELEASE( pDS );
        GetDXUTState().SetD3D11DepthStencil( nullptr );
        auto pDSV = GetDXUTState().GetD3D11DepthStencilView();
        SAFE_RELEASE( pDSV );
        GetDXUTState().SetD3D11DepthStencilView( nullptr );

        // Cleanup the render target view
        auto pRTV = GetDXUTState().GetD3D11RenderTargetView();
        SAFE_RELEASE( pRTV );
        GetDXUTState().SetD3D11RenderTargetView( nullptr );

        // Call the app's device destroyed callback
        if( GetDXUTState().GetDeviceObjectsCreated() )
        {
            auto pCallbackDeviceDestroyed = GetDXUTState().GetD3D11DeviceDestroyedFunc();
            if( pCallbackDeviceDestroyed )
                pCallbackDeviceDestroyed( GetDXUTState().Get


esting.T) {
	assert.Nil(t, TestnetChainConfig.CheckConfigForkOrder())
	assert.Nil(t, MainnetChainConfig.CheckConfigForkOrder())
}

func TestChainConfig_Copy(t *testing.T) {
	// Temporarily modify MainnetChainConfig to simulate copying `nil` field.
	savedBlock := MainnetChainConfig.LondonCompatibleBlock
	MainnetChainConfig.LondonCompatibleBlock = nil
	defer func() { MainnetChainConfig.LondonCompatibleBlock = savedBlock }()

	a := MainnetChainConfig
	b := a.Copy()

	// simple field
	assert.Equal(t, a.UnitPrice, b.UnitPrice)
	b.UnitPrice = 0x1111
	assert.NotEqual(t, a.UnitPrice, b.UnitPrice)

	// nested field
	assert.Equal(t, a.Istanbul.Epoch, b.Istanbul.Epoch)
	b.Istanbul.Epoch = 0x2222
	assert.NotEqual(t, a.Istanbul.Epoch, b.Istanbul.Epoch)

	// non-nil pointer field with omitempty
	assert.NotNil(t, a.IstanbulCompatibleBlock)
	assert.Equal(t, a.IstanbulCompatibleBlock, b.IstanbulCompatibleBlock)
	b.IstanbulCompatibleBlock = big.NewInt(111111)
	assert.NotEqual(t, a.IstanbulCompatibleBlock, b.IstanbulCompatibleBlock)

	// nil pointer field with omitempty
	assert.Nil(t, a.LondonCompatibleBlock)
	assert.Equal(t, a.LondonCompatibleBlock, b.LondonCompatibleBlock)
	b.LondonCompatibleBlock = big.NewInt(222222)
	assert.NotEqual(t, a.LondonCompatibleBlock, b.LondonCompatibleBlock)

	// non-nil pointer field without omitempty
	assert.Equal(t, a.Governance.Reward.MintingAmount, b.Governance.Reward.MintingAmount)
	b.Governance.Reward.MintingAmount = big.NewInt(3333333)
	assert.NotEqual(t, a.Governance.Reward.MintingAmount, b.Governance.Reward.MintingAmount)

	// nested field of *struct type
	assert.Equal(t, a.Governance.Reward.Ratio, b.Governance.Reward.Ratio)
	b.Governance.Reward = &RewardConfig{Ratio: "11/22/33"}
	assert.NotEqual(t, a.Governance.Reward.Ratio, b.Governance.Reward.Ratio)
}

func BenchmarkChainConfig_Copy(b *testing.B) {
	a := MainnetChainConfig
	for i := 0; i < b.N; i++ {
		a.Copy()
	}
}
// Modifications Copyright 2024 The Kaia Authors
// Modifications Copyright 2018 The klaytn Authors
// Copyright 2016 The go-ethereum Authors
// This file is part of go-ethereum.
//
// go-ethereum 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 3 of the License, or
// (at your option) any later version.
//
// go-ethereum 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
//
// This file is derived from ethclient/ethclient_test.go (2018/06/04).
// Modified and improved for the klaytn development.
// Modified and improved for the Kaia development.

package client

import kaia "github.com/klaytn/klaytn"

// Verify that Client implements the Kaia interfaces.
var (
	// _ = kaia.Subscription(&Client{})
	_ = kaia.ChainReader(&Client{})
	_ = kaia.TransactionReader(&Client{})


/* UIxMailUserRightsEditor.h - this file is part of SOGo
 *
 * Copyright (C) 2007-2013 Inverse inc.
 *
 * This file 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, or (at your option)
 * any later version.
 *
 * This file 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; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifndef UIXMAILUSERRIGHTSEDITOR_H
#define UIXMAILUSERRIGHTSEDITOR_H

#import <UI/Common/UIxUserRightsEditor.h>

@interface UIxMailUserRightsEditor : UIxUserRightsEditor

- (void) setUserCanReadMails: (BOOL) userCanReadMails;
- (BOOL) userCanReadMails;

- (void) setUserCanWriteMails: (BOOL) userCanWriteMails;
- (BOOL) userCanWriteMails;

- (void) setUserCanInsertMails: (BOOL) userCanInsertMails;
- (BOOL) userCanInsertMails;

- (void) setUserCanMarkMailsRead: (BOOL) userCanMarkMailsRead;
- (BOOL) userCanMarkMailsRead;

- (void) setUserCanEraseMails: (BOOL) userCanEraseMails;
- (BOOL) userCanEraseMails;

- (void) setUserCanCreateSubfolders: (BOOL) userCanCreateSubfolders;
- (BOOL) userCanCreateSubfolders;

- (void) setUserCanPostMails: (BOOL) userCanPostMails;
- (BOOL) userCanPostMails;

- (void) setUserIsAdministrator: (BOOL) userIsAdministrator;
- (BOOL) userIsAdministrator;

@end

#endif /* UIXMAILUSERRIGHTSEDITOR_H */