Monthly Archives: February 2026

More concise steps to create GATHUB done by GROK

Leave a comment

# 1. Install Prettier + import sorter
npm install –save-dev \
prettier \
@ianvs/prettier-plugin-sort-imports

# 2. Create .prettierrc
cat > .prettierrc << ‘EOF’
{
“semi”: true,
“trailingComma”: “es5”,
“singleQuote”: true,
“printWidth”: 100,
“tabWidth”: 2,
“useTabs”: false,
“bracketSpacing”: true,
“arrowParens”: “avoid”,
“plugins”: [“@ianvs/prettier-plugin-sort-imports”],
“importOrder”: [“^node:”, “”, “^@/”, “^[./]”], “importOrderSeparation”: true,
“importOrderSortSpecifiers”: true
}
EOF

# 3. Create .prettierignore
cat > .prettierignore << ‘EOF’
dist/
node_modules/
*.log
.DS_Store
.vscode/
*.d.ts
*.tsbuildinfo
EOF

# 4. Add scripts to package.json (edit manually or append)
# Open package.json and make sure “scripts” includes:
“format”: “prettier –write \”src/**/*.ts\””,
“format:check”: “prettier –check \”src/**/*.ts\””

# Quick one-liner to add them (careful: overwrites existing scripts section) # Alternative: just edit package.json in VS Code / nano
jq ‘.scripts += {“format”: “prettier –write \”src/**/*.ts\””, “format:check”: “prettier –check \”src/**/*.ts\””}’ package.json > tmp.json && mv tmp.json package.json

# 5. Format all files now
npm run format

# 6. Commit the changes
git add .
git commit -m “Add Prettier config and formatting scripts”

AND THEN NEXT

{
“editor.defaultFormatter”: “esbenp.prettier-vscode”,
“editor.formatOnSave”: true,
“[typescript]”: {
“editor.defaultFormatter”: “esbenp.prettier-vscode”
}
}

GROK Script to move files to GITHUB

Leave a comment

#!/usr/bin/env bash

set -euo pipefail

# ────────────────────────────────────────────────
# Configuration – change these if you want
# ────────────────────────────────────────────────

REPO_NAME=”max-resonance-system”
DESCRIPTION=”MAX resonance & consciousness field engines (YAML modules)” VISIBILITY=”public” # or “private”
GIT_USERNAME=”ram133″

# ────────────────────────────────────────────────

echo “Creating local project for GitHub user: $GIT_USERNAME” echo “Repo name : $REPO_NAME”
echo “Visibility : $VISIBILITY”
echo “Description : $DESCRIPTION”
echo

read -p “Continue? (y/N) ” -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
echo “Aborted.”
exit 1
fi

# Create clean directory
mkdir -p “$REPO_NAME”
cd “$REPO_NAME”

# Create all the YAML files
cat > max_resonance.yml << ‘EOF’
name: max_resonance
version: 1.0.0
description: “Core resonance engine for harmonics, coherence, and field amplification.” inputs:
base_frequency:
type: number
carrier_frequency:
type: number
amplitude:
type: number
intention:
type: string
logic:
resonance_ratio: “{{ carrier_frequency / base_frequency }}” harmonic_index: “{{ resonance_ratio * amplitude }}”
coherence_factor: “{{ harmonic_index | abs }}”
intention_imprint: “{{ intention }}”
outputs:
resonance_field: “{{ coherence_factor }}”
harmonic_profile: “{{ harmonic_index }}”
imprinted_intention: “{{ intention_imprint }}”
EOF

cat > max_hertz.yml << ‘EOF’
name: max_hertz
version: 1.0.0
description: “Base frequency selector and normalization engine.” inputs:
target_state:
type: string
base_hz:
type: number
logic:
state_map:
relax: 432
focus: 528
deep_state: 963
sleep: 396
mapped_frequency: “{{ state_map[target_state] || base_hz }}” normalized_frequency: “{{ mapped_frequency }}”
outputs:
primary_hz: “{{ normalized_frequency }}”
state_tag: “{{ target_state }}”
EOF

# … repeat the same pattern for all other files …

# (I’m not pasting all 30+ cat blocks here to keep this readable — # copy-paste the remaining ones from your message into the script)

# Quick way if you’re lazy: paste this block and replace with real content: # cat > max_energy.yml << ‘EOF’
# … paste content …
# EOF

# After all files are created:

git init
git add .
git commit -m “Initial commit – MAX resonance YAML engine modules”

# Create remote repo (requires gh CLI + auth)
echo “Creating GitHub repository: $GIT_USERNAME/$REPO_NAME ($VISIBILITY)” gh repo create “$GIT_USERNAME/$REPO_NAME” \
–description “$DESCRIPTION” \
–“$VISIBILITY” \
–source=. \
–remote=origin \
–push \
–disable-wiki –disable-issues –disable-projects || {
echo
echo “Failed to create repo. Possible reasons:”
echo ” • Already exists → delete it first: gh repo delete $GIT_USERNAME/$REPO_NAME –yes” echo ” • Not logged in → run: gh auth login”
echo ” • gh not installed → install from https://cli.github.com” exit 1
}

echo
echo “Done!”
echo
echo “Repository should now be live at:”
echo “https://github.com/$GIT_USERNAME/$REPO_NAME”
echo
echo “Next steps (optional):”
echo ” gh repo edit –enable-wiki=false –enable-issues=false” echo ” git tag v1.0.0 && git push –tags”

Do it all script?

Leave a comment

scripts/max_godmode.ts
import { promises as fs } from “fs”;
import * as path from “path”;

type ModuleDefinition = {
name: string;
version?: string;
description?: string;
inputs?: Record;
logic?: Record;
outputs?: Record;
};

type GodModeConfig = {
mode: “generate_all” | “from_json” | “bootstrap_repo” | “auto_create”; targetDir: string;
modules?: ModuleDefinition[];
jsonPath?: string;
repoName?: string;
};

const defaultModules: ModuleDefinition[] = [
{ name: “max_resonance”, description: “Core resonance engine for harmonics, coherence, and field amplification.” },
{ name: “max_hertz”, description: “Base frequency selector and normalization engine.” },
{ name: “max_energy”, description: “Energy field amplifier and distribution engine.” },
{ name: “max_theta”, description: “Theta brainwave tuning and deep-state induction.” },
{ name: “max_binaural”, description: “Binaural beat generator for dual-channel entrainment.” },
{ name: “max_hemisync”, description: “Hemispheric synchronization and coherence engine.” },
{ name: “max_solfeggio”, description: “Solfeggio frequency selector and mapping engine.” },
{ name: “max_chakra”, description: “Chakra tuning, mapping, and alignment engine.” },
{ name: “max_pineal”, description: “Pineal activation and signal clarity engine.” },
{ name: “max_lucid”, description: “Lucid dreaming induction and stabilization engine.” },
{ name: “max_astral”, description: “Astral projection readiness and launch window engine.” },
{ name: “max_gateway”, description: “Gateway protocol for transitioning between states and layers.” },
{ name: “max_portal”, description: “Portal targeting and stabilization engine.” },
{ name: “max_vortex”, description: “Vortex spin, pull, and field curvature engine.” },
{ name: “max_dimension”, description: “Dimensional address, tuning, and lock-in engine.” },
{ name: “max_quantum”, description: “Quantum possibility field and superposition engine.” },
{ name: “max_timeline”, description: “Timeline selection, branching, and alignment engine.” },
{ name: “max_manifest”, description: “Manifestation projection and materialization engine.” },
{ name: “max_ux”, description: “User experience mapping, clarity, and guidance engine.” },
{ name: “max_feedback”, description: “Feedback capture, reflection, and adaptation engine.” }, { name: “max_logs”, description: “Event logging and traceability engine.” },
{ name: “max_secure”, description: “Security, integrity, and access control engine.” },
{ name: “max_remote”, description: “Remote control, signaling, and command routing engine.” },
{ name: “max_social”, description: “Social signal, sharing, and resonance propagation engine.” },
{ name: “max_seo”, description: “Discovery, keyword, and search alignment engine.” } ];

const baseHybridTemplate = (def: ModuleDefinition) => {
const name = def.name;
const version = def.version || “1.0.0”;
const description = def.description || “”;
const inputs = def.inputs || {};
const logic = def.logic || {};
const outputs = def.outputs || {};

const yamlInputs = Object.keys(inputs).length
? Object.entries(inputs)
.map(([key, val]) => ` ${key}:\n type: ${val.type}`) .join(“\n”)
: “”;
const yamlLogic = Object.keys(logic).length
? Object.entries(logic)
.map(([key, val]) => ` ${key}: ${JSON.stringify(val)}`) .join(“\n”)
: “”;
const yamlOutputs = Object.keys(outputs).length
? Object.entries(outputs)
.map(([key, val]) => ` ${key}: ${JSON.stringify(val)}`) .join(“\n”)
: “”;

return [
`name: ${name}`,
`version: ${version}`,
`description: “${description}”`,
`inputs:${yamlInputs ? “\n” + yamlInputs : ” {}”}`,
`logic:${yamlLogic ? “\n” + yamlLogic : ” {}”}`,
`outputs:${yamlOutputs ? “\n” + yamlOutputs : ” {}”}`
].join(“\n”);
};

const defaultHybridLogic: Record> = { max_resonance: {
inputs: {
base_frequency: { type: “number” },
carrier_frequency: { type: “number” },
amplitude: { type: “number” },
intention: { type: “string” }
},
logic: {
resonance_ratio: “{{ carrier_frequency / base_frequency }}”, harmonic_index: “{{ resonance_ratio * amplitude }}”,
coherence_factor: “{{ harmonic_index | abs }}”,
intention_imprint: “{{ intention }}”
},
outputs: {
resonance_field: “{{ coherence_factor }}”,
harmonic_profile: “{{ harmonic_index }}”,
imprinted_intention: “{{ intention_imprint }}”
}
},
max_hertz: {
inputs: {
target_state: { type: “string” },
base_hz: { type: “number” }
},
logic: {
state_map: {
relax: 432,
focus: 528,
deep_state: 963,
sleep: 396
},
mapped_frequency: “{{ state_map[target_state] || base_hz }}”, normalized_frequency: “{{ mapped_frequency }}”
},
outputs: {
primary_hz: “{{ normalized_frequency }}”,
state_tag: “{{ target_state }}”
}
},
max_energy: {
inputs: {
source_frequency: { type: “number” },
resonance_field: { type: “number” },
intensity: { type: “number” },
intention: { type: “string” }
},
logic: {
base_energy: “{{ source_frequency * intensity }}”,
amplified_energy: “{{ base_energy * (1 + resonance_field) }}”, stabilized_energy: “{{ amplified_energy }}”,
encoded_intention: “{{ intention }}”
},
outputs: {
energy_field_strength: “{{ stabilized_energy }}”,
energy_signature: “{{ encoded_intention }}”
}
},
max_theta: {
inputs: {
base_hz: { type: “number” },
depth: { type: “number” },
intention: { type: “string” }
},
logic: {
theta_center: 7,
theta_band_low: 4,
theta_band_high: 8,
tuned_frequency: “{{ theta_center + (depth * 0.5) }}”,
clamped_frequency: “{{ [theta_band_low, tuned_frequency, theta_band_high] | sort | slice:1,1 | first }}”, intention_channel: “{{ intention }}”
},
outputs: {
theta_frequency: “{{ clamped_frequency }}”,
theta_intention: “{{ intention_channel }}”
}
},
max_binaural: {
inputs: {
carrier_frequency: { type: “number” },
offset: { type: “number” },
mode: { type: “string” }
},
logic: {
mode_map: {
theta: 7,
alpha: 10,
delta: 3,
beta: 18
},
effective_offset: “{{ mode_map[mode] || offset }}”,
left_channel: “{{ carrier_frequency – (effective_offset / 2) }}”, right_channel: “{{ carrier_frequency + (effective_offset / 2) }}” },
outputs: {
left_hz: “{{ left_channel }}”,
right_hz: “{{ right_channel }}”,
binaural_mode: “{{ mode }}”
}
},
max_hemisync: {
inputs: {
left_hz: { type: “number” },
right_hz: { type: “number” },
resonance_field: { type: “number” }
},
logic: {
frequency_delta: “{{ (right_hz – left_hz) | abs }}”,
sync_index: “{{ 1 / (1 + frequency_delta) }}”,
coherence_score: “{{ sync_index * (1 + resonance_field) }}” },
outputs: {
hemispheric_coherence: “{{ coherence_score }}”,
sync_delta: “{{ frequency_delta }}”
}
},
max_solfeggio: {
inputs: {
code: { type: “string” },
intention: { type: “string” }
},
logic: {
solfeggio_map: {
“396”: “liberation from fear and guilt”,
“417”: “facilitating change”,
“528”: “transformation and miracles”,
“639”: “connection and relationships”,
“741”: “intuition and problem solving”,
“852”: “spiritual order”,
“963”: “oneness and unity”
},
frequency_value: “{{ code | to_number }}”,
meaning: “{{ solfeggio_map }}",
encoded_intention: "{{ intention }}"
},
outputs: {
solfeggio_hz: "{{ frequency_value }}",
solfeggio_meaning: "{{ meaning }}",
solfeggio_intention: "{{ encoded_intention }}"
}
},
max_chakra: {
inputs: {
chakra: { type: "string" },
intensity: { type: "number" },
intention: { type: "string" }
},
logic: {
chakra_map_hz: {
root: 396,
sacral: 417,
solar_plexus: 528,
heart: 639,
throat: 741,
third_eye: 852,
crown: 963
},
chakra_color_map: {
root: "red",
sacral: "orange",
solar_plexus: "yellow",
heart: "green",
throat: "blue",
third_eye: "indigo",
crown: "violet"
},
base_frequency: "{{ chakra_map_hz[chakra] }}",
tuned_frequency: "{{ base_frequency * (1 + (intensity * 0.1)) }}", chakra_color: "{{ chakra_color_map[chakra] }}",
encoded_intention: "{{ intention }}"
},
outputs: {
chakra_frequency: "{{ tuned_frequency }}",
chakra_color: "{{ chakra_color }}",
chakra_intention: "{{ encoded_intention }}"
}
},
max_pineal: {
inputs: {
carrier_frequency: { type: "number" },
theta_frequency: { type: "number" },
intention: { type: "string" }
},
logic: {
alignment_delta: "{{ (carrier_frequency - theta_frequency) | abs }}", clarity_index: "{{ 1 / (1 + alignment_delta) }}",
activation_level: "{{ clarity_index * 1.618 }}",
encoded_intention: "{{ intention }}"
},
outputs: {
pineal_activation: "{{ activation_level }}",
pineal_clarity: "{{ clarity_index }}",
pineal_intention: "{{ encoded_intention }}"
}
},
max_lucid: {
inputs: {
theta_frequency: { type: "number" },
binaural_delta: { type: "number" },
intention: { type: "string" }
},
logic: {
ideal_delta: 4,
delta_alignment: "{{ 1 / (1 + (binaural_delta - ideal_delta) | abs) }}", dream_stability: "{{ delta_alignment * 1.5 }}",
lucidity_index: "{{ dream_stability * 1.2 }}",
encoded_intention: "{{ intention }}"
},
outputs: {
lucid_potential: "{{ lucidity_index }}",
dream_stability_score: "{{ dream_stability }}",
lucid_intention: "{{ encoded_intention }}"
}
},
max_astral: {
inputs: {
pineal_activation: { type: "number" },
lucid_potential: { type: "number" },
energy_field_strength: { type: "number" },
intention: { type: "string" }
},
logic: {
readiness_index: "{{ (pineal_activation + lucid_potential + energy_field_strength) / 3 }}", threshold: 1.0,
launch_window: "{{ readiness_index > threshold }}",
encoded_intention: "{{ intention }}"
},
outputs: {
astral_readiness: "{{ readiness_index }}",
astral_launch_window: "{{ launch_window }}",
astral_intention: "{{ encoded_intention }}"
}
},
max_gateway: {
inputs: {
astral_readiness: { type: "number" },
hemispheric_coherence: { type: "number" },
intention: { type: "string" }
},
logic: {
gateway_index: "{{ (astral_readiness + hemispheric_coherence) / 2 }}", open_threshold: 0.8,
gateway_open: "{{ gateway_index > open_threshold }}",
encoded_intention: "{{ intention }}"
},
outputs: {
gateway_state: "{{ gateway_open }}",
gateway_strength: "{{ gateway_index }}",
gateway_intention: "{{ encoded_intention }}"
}
},
max_portal: {
inputs: {
gateway_state: { type: "boolean" },
target_signature: { type: "string" },
intention: { type: "string" }
},
logic: {
portal_active: "{{ gateway_state }}",
target_lock: "{{ target_signature }}",
stability_index: "{{ portal_active | ternary: 1.0, 0.0 }}", encoded_intention: "{{ intention }}"
},
outputs: {
portal_open: "{{ portal_active }}",
portal_target: "{{ target_lock }}",
portal_stability: "{{ stability_index }}",
portal_intention: "{{ encoded_intention }}"
}
},
max_vortex: {
inputs: {
energy_field_strength: { type: "number" },
portal_stability: { type: "number" },
intention: { type: "string" }
},
logic: {
spin_rate: "{{ energy_field_strength * 0.618 }}",
pull_intensity: "{{ spin_rate * portal_stability }}",
curvature_index: "{{ pull_intensity * 0.5 }}",
encoded_intention: "{{ intention }}"
},
outputs: {
vortex_spin: "{{ spin_rate }}",
vortex_pull: "{{ pull_intensity }}",
vortex_curvature: "{{ curvature_index }}",
vortex_intention: "{{ encoded_intention }}"
}
},
max_dimension: {
inputs: {
portal_target: { type: "string" },
vortex_curvature: { type: "number" },
intention: { type: "string" }
},
logic: {
dimension_code: "{{ portal_target }}",
lock_index: "{{ 1 / (1 + (1 - vortex_curvature) | abs) }}", encoded_intention: "{{ intention }}"
},
outputs: {
dimension_address: "{{ dimension_code }}",
dimension_lock: "{{ lock_index }}",
dimension_intention: "{{ encoded_intention }}"
}
},
max_quantum: {
inputs: {
dimension_address: { type: "string" },
intention: { type: "string" },
energy_field_strength: { type: "number" }
},
logic: {
possibility_spread: "{{ energy_field_strength * 2 }}",
collapse_bias: "{{ intention }}",
coherence_index: "{{ possibility_spread * 0.5 }}"
},
outputs: {
quantum_field_strength: "{{ possibility_spread }}",
quantum_coherence: "{{ coherence_index }}",
quantum_bias: "{{ collapse_bias }}"
}
},
max_timeline: {
inputs: {
quantum_coherence: { type: "number" },
quantum_bias: { type: "string" },
intention: { type: "string" }
},
logic: {
alignment_index: "{{ quantum_coherence * 0.8 }}",
branch_label: "{{ quantum_bias }}",
encoded_intention: "{{ intention }}"
},
outputs: {
timeline_alignment: "{{ alignment_index }}",
timeline_branch: "{{ branch_label }}",
timeline_intention: "{{ encoded_intention }}"
}
},
max_manifest: {
inputs: {
timeline_alignment: { type: "number" },
energy_field_strength: { type: "number" },
intention: { type: "string" }
},
logic: {
manifestation_potential: "{{ (timeline_alignment + energy_field_strength) / 2 }}", threshold: 1.0,
manifestation_ready: "{{ manifestation_potential > threshold }}", encoded_intention: "{{ intention }}"
},
outputs: {
manifest_potential: "{{ manifestation_potential }}",
manifest_ready: "{{ manifestation_ready }}",
manifest_intention: "{{ encoded_intention }}"
}
},
max_ux: {
inputs: {
current_state: { type: "string" },
target_state: { type: "string" },
complexity_level: { type: "number" }
},
logic: {
guidance_intensity: "{{ 1 / (1 + complexity_level) }}", clarity_score: "{{ guidance_intensity * 1.5 }}",
journey_label: "{{ current_state | append: ' → ' | append: target_state }}" },
outputs: {
ux_clarity: "{{ clarity_score }}",
ux_guidance_intensity: "{{ guidance_intensity }}",
ux_journey: "{{ journey_label }}"
}
},
max_feedback: {
inputs: {
session_id: { type: "string" },
user_signal: { type: "string" },
intensity: { type: "number" }
},
logic: {
normalized_intensity: "{{ intensity }}",
feedback_packet: "{{ user_signal }}",
adaptation_weight: "{{ normalized_intensity * 0.8 }}"
},
outputs: {
feedback_intensity: "{{ normalized_intensity }}",
feedback_content: "{{ feedback_packet }}",
feedback_weight: "{{ adaptation_weight }}"
}
},
max_logs: {
inputs: {
session_id: { type: "string" },
event_type: { type: "string" },
payload: { type: "string" }
},
logic: {
log_entry: "{{ session_id | append: '|' | append: event_type | append: '|' | append: payload }}", log_level: "{{ event_type }}"
},
outputs: {
log_record: "{{ log_entry }}",
log_category: "{{ log_level }}"
}
},
max_secure: {
inputs: {
session_id: { type: "string" },
user_role: { type: "string" },
requested_action: { type: "string" }
},
logic: {
role_permissions: {
admin: ["read", "write", "execute"],
user: ["read", "execute"],
guest: ["read"]
},
allowed_actions: "{{ role_permissions[user_role] }}",
is_allowed: "{{ allowed_actions contains requested_action }}" },
outputs: {
access_granted: "{{ is_allowed }}",
access_role: "{{ user_role }}",
access_action: "{{ requested_action }}"
}
},
max_remote: {
inputs: {
session_id: { type: "string" },
command: { type: "string" },
target_module: { type: "string" }
},
logic: {
routed_command: "{{ command }}",
routed_target: "{{ target_module }}",
control_token: "{{ session_id }}"
},
outputs: {
remote_command: "{{ routed_command }}",
remote_target: "{{ routed_target }}",
remote_token: "{{ control_token }}"
}
},
max_social: {
inputs: {
session_id: { type: "string" },
share_intent: { type: "string" },
resonance_field: { type: "number" }
},
logic: {
share_strength: "{{ resonance_field * 1.2 }}",
share_payload: "{{ share_intent }}"
},
outputs: {
social_share_strength: "{{ share_strength }}",
social_share_payload: "{{ share_payload }}",
social_session: "{{ session_id }}"
}
},
max_seo: {
inputs: {
title: { type: "string" },
description: { type: "string" },
primary_intent: { type: "string" }
},
logic: {
keyword_seed: "{{ primary_intent }}",
slug: "{{ title | downcase | replace: ' ', '-' }}",
meta_description: "{{ description }}"
},
outputs: {
seo_slug: "{{ slug }}",
seo_keyword: "{{ keyword_seed }}",
seo_meta_description: "{{ meta_description }}"
}
}
};

async function ensureDir(dir: string) {
await fs.mkdir(dir, { recursive: true });
}

async function writeModuleFile(targetDir: string, def: ModuleDefinition) { const enriched = {
...def,
...(defaultHybridLogic[def.name] || {})
};
const content = baseHybridTemplate(enriched);
const filePath = path.join(targetDir, `${def.name}.yml`);
await fs.writeFile(filePath, content, "utf8");
}

async function generateAllModules(config: GodModeConfig) {
await ensureDir(config.targetDir);
for (const def of defaultModules) {
await writeModuleFile(config.targetDir, def);
}
}

async function generateFromJson(config: GodModeConfig) {
if (!config.jsonPath) return;
const jsonRaw = await fs.readFile(config.jsonPath, "utf8"); const parsed = JSON.parse(jsonRaw) as ModuleDefinition[];
await ensureDir(config.targetDir);
for (const def of parsed) {
await writeModuleFile(config.targetDir, def);
}
}

async function bootstrapRepo(config: GodModeConfig) {
const root = config.targetDir;
await ensureDir(root);
await ensureDir(path.join(root, "modules"));
await ensureDir(path.join(root, "scripts"));
await fs.writeFile(
path.join(root, "README.md"),
`# ${config.repoName || "max-stack"}\n\nMultidimensional MAX engine.\n`, "utf8"
);
await generateAllModules({ ...config, targetDir: path.join(root, "modules") }); }

async function autoCreateModules(config: GodModeConfig) {
const modules = config.modules || defaultModules;
await ensureDir(config.targetDir);
for (const def of modules) {
await writeModuleFile(config.targetDir, def);
}
}

async function main() {
const raw = process.env.MAX_GODMODE_CONFIG || "";
if (!raw) {
process.exit(0);
}
const config = JSON.parse(raw) as GodModeConfig;
if (config.mode === "generate_all") {
await generateAllModules(config);
} else if (config.mode === "from_json") {
await generateFromJson(config);
} else if (config.mode === "bootstrap_repo") {
await bootstrapRepo(config);
} else if (config.mode === "auto_create") {
await autoCreateModules(config);
}
}

main().catch(() => {
process.exit(1);
});