@shipload/sdk 1.0.0-next.62 → 1.0.0-next.64

package/src/influence/decomp.ts

@@ -0,0 +1,95 @@
+import {tryGetItem} from '../data/catalog'
+import {getRecipe} from '../data/recipes-runtime'
+import recipes from '../data/recipes.json'
+import {
+    DECOMP_MAX_BUCKETS,
+    DECOMP_MAX_DEPTH,
+    DECOMP_PROCESSED_KG_MAX,
+    DECOMP_RAW_KG_MAX,
+} from './constants'
+import {categoryIndex} from './categories'
+
+export interface DecompBucket {
+    category: number
+    tier: number
+    rawKg: number
+}
+
+export interface DecompEntry {
+    itemId: number
+    processedKg: number
+    buckets: DecompBucket[]
+}
+
+interface Accumulator {
+    buckets: DecompBucket[]
+    processedKg: number
+    overflow: boolean
+}
+
+function add(acc: Accumulator, category: number, tier: number, kg: number): void {
+    const existing = acc.buckets.find((b) => b.category === category && b.tier === tier)
+    if (existing) {
+        existing.rawKg += kg
+        return
+    }
+    if (acc.buckets.length >= DECOMP_MAX_BUCKETS) {
+        acc.overflow = true
+        return
+    }
+    acc.buckets.push({category, tier, rawKg: kg})
+}
+
+function walk(itemId: number, multiplier: number, acc: Accumulator, depth: number): void {
+    if (depth > DECOMP_MAX_DEPTH) {
+        acc.overflow = true
+        return
+    }
+    const recipe = getRecipe(itemId)
+    if (!recipe) return
+
+    for (const input of recipe.inputs) {
+        const def = tryGetItem(input.itemId)
+        const units = multiplier * input.quantity
+        const kg = units * (def ? def.mass : 0)
+        acc.processedKg += kg
+        if (getRecipe(input.itemId)) {
+            walk(input.itemId, units, acc, depth + 1)
+        } else if (def?.type !== 'resource' || def.category === undefined) {
+            acc.overflow = true
+        } else {
+            add(acc, categoryIndex(def.category), def.tier, kg)
+        }
+    }
+}
+
+function buildRegistry(): DecompEntry[] {
+    const out: DecompEntry[] = []
+    for (const recipe of recipes as {outputItemId: number}[]) {
+        const acc: Accumulator = {buckets: [], processedKg: 0, overflow: false}
+        walk(recipe.outputItemId, 1, acc, 0)
+        acc.buckets.sort((a, b) => a.category - b.category || a.tier - b.tier)
+
+        const rawTotal = acc.buckets.reduce((sum, b) => sum + b.rawKg, 0)
+        if (rawTotal > DECOMP_RAW_KG_MAX || acc.processedKg > DECOMP_PROCESSED_KG_MAX) {
+            acc.overflow = true
+        }
+
+        out.push({
+            itemId: recipe.outputItemId,
+            processedKg: acc.overflow ? 0 : acc.processedKg,
+            buckets: acc.buckets,
+        })
+    }
+    out.sort((a, b) => a.itemId - b.itemId)
+    return out
+}
+
+export const DECOMP_REGISTRY: DecompEntry[] = buildRegistry()
+
+const byItemId = new Map<number, DecompEntry>()
+for (const entry of DECOMP_REGISTRY) byItemId.set(entry.itemId, entry)
+
+export function findDecomp(itemId: number): DecompEntry | undefined {
+    return byItemId.get(itemId)
+}

package/src/influence/demand.ts

@@ -0,0 +1,106 @@
+import {Checksum256, type Checksum256Type, type Checksum512} from '@wharfkit/antelope'
+import {getLocationProfile} from '../derivation/resources'
+import {Coordinates, type CoordinatesType} from '../types'
+import {hash512} from '../utils/hash'
+import {deriveLocationStatic} from '../utils/system'
+import {RESOURCE_CATEGORY_COUNT} from './constants'
+
+export interface DemandTriple {
+    peak: bigint
+    base: bigint
+    floor: bigint
+}
+
+export interface DemandView {
+    abundantMask: number
+    lackingMask: number
+    acute: number
+    needFp: bigint[]
+}
+
+const ALL_CATEGORIES_MASK = 0x1f
+
+export function abundantMaskFor(locationType: number, subtype: number): number {
+    let mask = 0
+    for (const entry of getLocationProfile(locationType, subtype)) {
+        mask |= 1 << entry.category
+    }
+    return mask
+}
+
+export function lackingMaskFrom(abundantMask: number): number {
+    return ~abundantMask & ALL_CATEGORIES_MASK
+}
+
+export function popcount5(mask: number): number {
+    let n = 0
+    for (let i = 0; i < RESOURCE_CATEGORY_COUNT; i++) if (mask & (1 << i)) n++
+    return n
+}
+
+export function pickAcuteCategory(lackingMask: number, roll: number): number {
+    const count = popcount5(lackingMask)
+    if (count === 0) throw new Error('location has no lacking category')
+    let index = roll % count
+    for (let c = 0; c < RESOURCE_CATEGORY_COUNT; c++) {
+        if ((lackingMask & (1 << c)) === 0) continue
+        if (index === 0) return c
+        index--
+    }
+    throw new Error('acute pick fell through')
+}
+
+export function demandRoll(hash: Checksum512): number {
+    const bytes = hash.array
+    return ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
+}
+
+export function buildDemand(abundantMask: number, acute: number, triple: DemandTriple): DemandView {
+    const lackingMask = lackingMaskFrom(abundantMask)
+    const needFp: bigint[] = []
+    for (let c = 0; c < RESOURCE_CATEGORY_COUNT; c++) {
+        if (c === acute) needFp.push(triple.peak)
+        else if (lackingMask & (1 << c)) needFp.push(triple.base)
+        else needFp.push(triple.floor)
+    }
+    return {abundantMask, lackingMask, acute, needFp}
+}
+
+export function needForCategory(demand: DemandView, category: number): bigint {
+    if (category < 0 || category >= RESOURCE_CATEGORY_COUNT) {
+        throw new Error('invalid category')
+    }
+    return demand.needFp[category]
+}
+
+// Two distinct seeds: composition from the genesis game seed, acute rotation from the epoch seed.
+export function deriveDemand(args: {
+    gameSeed: Checksum256Type
+    epochSeed: Checksum256Type
+    coordinates: CoordinatesType
+    triple: DemandTriple
+}): DemandView {
+    const coords = Coordinates.from(args.coordinates)
+    const location = deriveLocationStatic(args.gameSeed, coords)
+    const abundant = abundantMaskFor(Number(location.type), Number(location.subtype))
+    if (abundant === 0) throw new Error('location has no composition')
+
+    const hash = hash512(
+        Checksum256.from(args.epochSeed),
+        `demand-${coords.x.toString()}-${coords.y.toString()}`
+    )
+    const acute = pickAcuteCategory(lackingMaskFrom(abundant), demandRoll(hash))
+    return buildDemand(abundant, acute, args.triple)
+}
+
+export function isAbundant(demand: DemandView, category: number): boolean {
+    return (demand.abundantMask & (1 << category)) !== 0
+}
+
+export function isAcute(demand: DemandView, category: number): boolean {
+    return demand.acute === category
+}
+
+export function needMultiplier(demand: DemandView, category: number): number {
+    return Number(needForCategory(demand, category)) / 10_000
+}

package/src/influence/duration.ts

@@ -0,0 +1,36 @@
+import {computeLoaderMass, computeLoaderThrust} from '../nft/description'
+import {PRECISION} from '../types'
+import {CIVIC_LOADER_STAT, CIVIC_LOADER_TIER, DEFAULT_ORBITAL_Z} from './constants'
+
+export interface CivicLoaderStats {
+    thrust: number
+    mass: number
+}
+
+export function civicLoader(): CivicLoaderStats {
+    return {
+        thrust: Math.min(computeLoaderThrust(CIVIC_LOADER_STAT, CIVIC_LOADER_TIER), 65_535),
+        mass: computeLoaderMass(CIVIC_LOADER_STAT),
+    }
+}
+
+function acceleration(thrust: number, mass: number): number {
+    if (mass <= 0) return 0
+    return (thrust / mass) * PRECISION
+}
+
+function flightTime(distance: number, accel: number): number {
+    if (accel <= 0 || distance <= 0) return 0
+    return Math.floor(2 * Math.sqrt(distance / accel))
+}
+
+export function contributeDuration(totalMassKg: number, altitudeZ = 0): number {
+    const loader = civicLoader()
+    const totalMass = totalMassKg + loader.mass
+    const z = Math.max(altitudeZ, DEFAULT_ORBITAL_Z)
+    return flightTime(z, acceleration(loader.thrust, totalMass))
+}
+
+export function contributeDurationForTonnes(tonnes: number, altitudeZ = 0): number {
+    return contributeDuration(Math.floor(tonnes * 1000), altitudeZ)
+}

package/src/influence/index.ts

@@ -0,0 +1,63 @@
+export * from './constants'
+export * from './categories'
+export {decayActive, normalizeActive, type DecayableStanding} from './decay'
+export {getStatCount, statsSumSq, qualityFactor} from './quality'
+export {
+    DECOMP_REGISTRY,
+    findDecomp,
+    type DecompBucket,
+    type DecompEntry,
+} from './decomp'
+export {
+    abundantMaskFor,
+    buildDemand,
+    demandRoll,
+    deriveDemand,
+    isAbundant,
+    isAcute,
+    lackingMaskFrom,
+    needForCategory,
+    needMultiplier,
+    pickAcuteCategory,
+    popcount5,
+    type DemandTriple,
+    type DemandView,
+} from './demand'
+export {
+    componentBaseAtomic,
+    componentEffortAtomic,
+    pricingFromWeights,
+    resourceValueAtomic,
+    valueCargoItem,
+    valueContribution,
+    weightedQualityAtomic,
+    type InfluencePricing,
+    type ValuedItem,
+} from './valuation'
+export {
+    civicLoader,
+    contributeDuration,
+    contributeDurationForTonnes,
+    type CivicLoaderStats,
+} from './duration'
+export {citizenryName, citizenryPatternCount} from './citizenry'
+export {
+    charterEffectTargetEntity,
+    charterEffectTargetPresent,
+    charterEligible,
+    charterIneligible,
+    charterNode,
+    charterPrereqsMet,
+    charterSingletonMandate,
+    charterSpawnNodeFor,
+    CHARTER_INELIGIBILITY_MESSAGES,
+    CHARTER_REGISTRY,
+    effectiveMandate,
+    eligibleCharters,
+    type BuiltCharter,
+    type CharterEffect,
+    type CharterIneligibility,
+    type CharterNode,
+    type CharterWorld,
+    type ChosenCharter,
+} from './charters'

package/src/influence/influence.test.ts

@@ -0,0 +1,317 @@
+import {describe, expect, test} from 'bun:test'
+import {Checksum256} from '@wharfkit/antelope'
+import {ITEM_ORE_T1, ITEM_PLATE, ITEM_CRYSTAL_T1} from '../data/item-ids'
+import {categoryIndex} from './categories'
+import {
+    CHARTER_WORKSHOP_COST,
+    DEMAND_TRIPLE_SEED,
+    INFLUENCE_ATOMIC_PER_POINT,
+    INFLUENCE_D1_SEED,
+    NEED_FP_SCALE,
+} from './constants'
+import {decayActive, normalizeActive} from './decay'
+import {
+    buildDemand,
+    deriveDemand,
+    lackingMaskFrom,
+    needForCategory,
+    pickAcuteCategory,
+    popcount5,
+} from './demand'
+import {findDecomp, DECOMP_REGISTRY} from './decomp'
+import {contributeDuration} from './duration'
+import {getStatCount, statsSumSq} from './quality'
+import {pricingFromWeights, valueCargoItem, valueContribution} from './valuation'
+import {citizenryName, citizenryPatternCount} from './citizenry'
+import citizenryAdjectives from '../data/citizenry-adjectives.json'
+import citizenryNouns from '../data/citizenry-nouns.json'
+
+const PAR = 213
+const WORLD = {x: 56, y: 0}
+const packStats = (a: number, b = a, c = a): bigint =>
+    BigInt(a) | (BigInt(b) << 10n) | (BigInt(c) << 20n)
+
+const SEED_WEIGHTS_FP = [10000, 10510, 14289, 21964, 32326, 42658, 52913, 61128, 68570, 75380]
+
+const pricing = pricingFromWeights(
+    INFLUENCE_D1_SEED,
+    Array.from({length: 5}, (_, category) =>
+        SEED_WEIGHTS_FP.map((weightFp, i) => ({category, tier: i + 1, weightFp}))
+    ).flat()
+)
+
+const baseDemand = buildDemand(0, 255, DEMAND_TRIPLE_SEED)
+
+describe('decay', () => {
+    test('zero epochs is the identity', () => {
+        expect(decayActive(1_000_000n, 0)).toBe(1_000_000n)
+    })
+
+    test('one epoch retains 19/20 with a floor', () => {
+        expect(decayActive(1_000_000n, 1)).toBe(950_000n)
+        expect(decayActive(19n, 1)).toBe(18n)
+    })
+
+    test('is path independent', () => {
+        const direct = decayActive(123_456_789n, 7)
+        const staged = decayActive(decayActive(123_456_789n, 3), 4)
+        expect(staged).toBe(direct)
+    })
+
+    test('early-exits at zero and clamps the iteration count', () => {
+        expect(decayActive(0n, 5_000)).toBe(0n)
+        expect(decayActive(1_000_000n, 100_000)).toBe(decayActive(1_000_000n, 1_024))
+    })
+
+    test('normalizeActive never decays backwards', () => {
+        expect(normalizeActive({active: 1_000n, lastUpdateEpoch: 9}, 4)).toBe(1_000n)
+    })
+})
+
+describe('quality', () => {
+    test('par stats give exactly the quality divisor', () => {
+        expect(statsSumSq(packStats(PAR), 3)).toBe(3 * INFLUENCE_D1_SEED)
+    })
+
+    test('the retired Workshop falls back to three stats', () => {
+        expect(getStatCount(10208)).toBe(3)
+    })
+
+    test('a crafted component reports its recipe slot count', () => {
+        expect(getStatCount(ITEM_PLATE)).toBe(3)
+    })
+})
+
+describe('demand', () => {
+    test('the lacking mask is the complement over five categories', () => {
+        expect(lackingMaskFrom(0b00101)).toBe(0b11010)
+        expect(popcount5(0b11010)).toBe(3)
+    })
+
+    test('the acute pick indexes the lacking set only', () => {
+        const lacking = 0b10010
+        expect(pickAcuteCategory(lacking, 0)).toBe(1)
+        expect(pickAcuteCategory(lacking, 1)).toBe(4)
+        expect(pickAcuteCategory(lacking, 2)).toBe(1)
+    })
+
+    test('the triple assigns peak, base and floor', () => {
+        const view = buildDemand(0b00001, 1, DEMAND_TRIPLE_SEED)
+        expect(needForCategory(view, 0)).toBe(DEMAND_TRIPLE_SEED.floor)
+        expect(needForCategory(view, 1)).toBe(DEMAND_TRIPLE_SEED.peak)
+        expect(needForCategory(view, 2)).toBe(DEMAND_TRIPLE_SEED.base)
+    })
+
+    test('the acute pick rotates with the epoch seed, not the game seed', () => {
+        const gameSeed = Checksum256.hash(Buffer.from('game'))
+        const coordinates = WORLD
+        const picks = new Set<number>()
+        for (let i = 0; i < 24; i++) {
+            const epochSeed = Checksum256.hash(Buffer.from(`epoch-${i}`))
+            picks.add(
+                deriveDemand({gameSeed, epochSeed, coordinates, triple: DEMAND_TRIPLE_SEED}).acute
+            )
+        }
+        expect(picks.size).toBeGreaterThan(1)
+    })
+
+    test('the composition partition is stable across epochs', () => {
+        const gameSeed = Checksum256.hash(Buffer.from('game'))
+        const coordinates = WORLD
+        const masks = new Set<number>()
+        for (let i = 0; i < 8; i++) {
+            const epochSeed = Checksum256.hash(Buffer.from(`epoch-${i}`))
+            masks.add(
+                deriveDemand({gameSeed, epochSeed, coordinates, triple: DEMAND_TRIPLE_SEED})
+                    .abundantMask
+            )
+        }
+        expect(masks.size).toBe(1)
+    })
+})
+
+describe('decomposition', () => {
+    test('the registry is sorted by item id and covers every recipe', () => {
+        for (let i = 1; i < DECOMP_REGISTRY.length; i++) {
+            expect(DECOMP_REGISTRY[i].itemId).toBeGreaterThan(DECOMP_REGISTRY[i - 1].itemId)
+        }
+        expect(DECOMP_REGISTRY.length).toBe(57)
+    })
+
+    test('the retired Workshop has no decomposition entry', () => {
+        expect(findDecomp(10208)).toBeUndefined()
+    })
+
+    test('buckets are sorted and hold only raw resources', () => {
+        const entry = findDecomp(ITEM_PLATE)
+        if (!entry) throw new Error('Plate has no decomposition entry')
+        expect(entry.processedKg).toBeGreaterThan(0)
+        for (let i = 1; i < entry.buckets.length; i++) {
+            const prev = entry.buckets[i - 1]
+            const cur = entry.buckets[i]
+            expect(prev.category < cur.category || prev.tier < cur.tier).toBe(true)
+        }
+    })
+})
+
+describe('valuation', () => {
+    test('a tonne of par T1 ore at base demand is worth exactly one point', () => {
+        const value = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 1, stats: packStats(PAR)},
+            baseDemand,
+            pricing
+        )
+        expect(value).toBe(BigInt(INFLUENCE_ATOMIC_PER_POINT))
+    })
+
+    test('the acute multiplier doubles a resource', () => {
+        const acute = buildDemand(0, categoryIndex('crystal'), DEMAND_TRIPLE_SEED)
+        const item = {itemId: ITEM_CRYSTAL_T1, quantity: 3, stats: packStats(PAR)}
+        expect(valueCargoItem(item, acute, pricing)).toBe(
+            valueCargoItem(item, baseDemand, pricing) * 2n
+        )
+    })
+
+    test('resource valuation is split invariant', () => {
+        const one = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 1, stats: packStats(97)},
+            baseDemand,
+            pricing
+        )
+        const many = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 137, stats: packStats(97)},
+            baseDemand,
+            pricing
+        )
+        expect(many).toBe(one * 137n)
+    })
+
+    test('component valuation is split invariant', () => {
+        const one = valueCargoItem(
+            {itemId: ITEM_PLATE, quantity: 1, stats: packStats(PAR)},
+            baseDemand,
+            pricing
+        )
+        const many = valueCargoItem(
+            {itemId: ITEM_PLATE, quantity: 40, stats: packStats(PAR)},
+            baseDemand,
+            pricing
+        )
+        expect(many).toBe(one * 40n)
+    })
+
+    test('components ignore demand entirely', () => {
+        const acute = buildDemand(0, categoryIndex('ore'), DEMAND_TRIPLE_SEED)
+        const item = {itemId: ITEM_PLATE, quantity: 5, stats: packStats(PAR)}
+        expect(valueCargoItem(item, acute, pricing)).toBe(valueCargoItem(item, baseDemand, pricing))
+    })
+
+    test('quality scales quadratically within the per-unit floor tolerance', () => {
+        const single = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 100, stats: packStats(100)},
+            baseDemand,
+            pricing
+        )
+        const doubled = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 100, stats: packStats(200)},
+            baseDemand,
+            pricing
+        )
+        const delta = doubled - single * 4n
+        expect(delta >= -105n && delta <= 105n).toBe(true)
+    })
+
+    test('a bundle totals its rows', () => {
+        const bundle = [
+            {itemId: ITEM_ORE_T1, quantity: 10, stats: packStats(PAR)},
+            {itemId: ITEM_PLATE, quantity: 2, stats: packStats(PAR)},
+        ]
+        expect(valueContribution(bundle, baseDemand, pricing)).toBe(
+            valueCargoItem(bundle[0], baseDemand, pricing) +
+                valueCargoItem(bundle[1], baseDemand, pricing)
+        )
+    })
+
+    test('a packed entity cannot be valued', () => {
+        expect(() =>
+            valueCargoItem({itemId: 10208, quantity: 1, stats: packStats(PAR)}, baseDemand, pricing)
+        ).toThrow()
+    })
+
+    test('the Workshop charter costs 200,000 points of hauled par T1 material', () => {
+        const perTonne = valueCargoItem(
+            {itemId: ITEM_ORE_T1, quantity: 200_000, stats: packStats(PAR)},
+            baseDemand,
+            pricing
+        )
+        expect(perTonne).toBe(CHARTER_WORKSHOP_COST)
+    })
+})
+
+describe('contribution duration', () => {
+    test('grows with mass and never falls below a single tick', () => {
+        expect(contributeDuration(1_000)).toBeGreaterThan(0)
+        expect(contributeDuration(1_000_000)).toBeGreaterThan(contributeDuration(1_000))
+    })
+
+    test('splitting a haul costs more than one trip', () => {
+        const single = contributeDuration(100_000_000)
+        const hundred = contributeDuration(1_000_000) * 100
+        expect(hundred).toBeGreaterThan(single)
+    })
+
+    test('ground level is floored at the base orbital climb', () => {
+        expect(contributeDuration(1_000, 0)).toBe(contributeDuration(1_000, 800))
+    })
+})
+
+describe('citizenry names', () => {
+    const gameSeed = Checksum256.hash(Buffer.from('game'))
+
+    test('is deterministic for a coordinate', () => {
+        const a = citizenryName(gameSeed, WORLD)
+        const b = citizenryName(gameSeed, WORLD)
+        expect(a).toBeDefined()
+        expect(a).toBe(b as string)
+    })
+
+    test('composes the world name with a known noun', () => {
+        const name = citizenryName(gameSeed, WORLD) ?? ''
+        expect(name.length).toBeGreaterThan(0)
+        expect(citizenryNouns.some((noun) => name.includes(noun))).toBe(true)
+    })
+
+    test('spreads across nouns and forms', () => {
+        const names: string[] = []
+        for (let x = 0; x < 160 && names.length < 200; x++) {
+            for (let y = 0; y < 160 && names.length < 200; y++) {
+                const name = citizenryName(gameSeed, {x, y})
+                if (name) names.push(name)
+            }
+        }
+        expect(names.length).toBeGreaterThan(100)
+
+        const nouns = new Set(names.map((n) => citizenryNouns.find((noun) => n.includes(noun))))
+        expect(nouns.size).toBeGreaterThan(20)
+
+        const ofForm = names.filter((n) => n.includes(' of ')).length
+        expect(ofForm).toBeGreaterThan(0)
+        expect(ofForm).toBeLessThan(names.length * 0.6)
+    })
+
+    test('counts every noun and adjective combination', () => {
+        expect(citizenryPatternCount()).toBe(
+            citizenryNouns.length * (1 + 2 * citizenryAdjectives.length)
+        )
+    })
+
+    test('is undefined away from a world', () => {
+        expect(citizenryName(gameSeed, {x: 7, y: 11})).toBeUndefined()
+    })
+})
+
+describe('scales', () => {
+    test('the need scale divides out against the atomic unit', () => {
+        expect(NEED_FP_SCALE % INFLUENCE_ATOMIC_PER_POINT).toBe(0)
+    })
+})

package/src/influence/quality.ts

@@ -0,0 +1,25 @@
+import {getRecipe} from '../data/recipes-runtime'
+import {decodeStat} from '../derivation/crafting'
+
+const CRAFTED_ITEM_ID_FLOOR = 10_000
+const UNCRAFTED_STAT_COUNT = 3
+
+export function getStatCount(itemId: number): number {
+    if (itemId < CRAFTED_ITEM_ID_FLOOR) return UNCRAFTED_STAT_COUNT
+    const recipe = getRecipe(itemId)
+    return recipe ? recipe.statSlots.length : UNCRAFTED_STAT_COUNT
+}
+
+export function statsSumSq(packedStats: bigint, nStats: number): number {
+    let sum = 0
+    for (let i = 0; i < nStats; i++) {
+        const s = decodeStat(packedStats, i)
+        sum += s * s
+    }
+    return sum
+}
+
+export function qualityFactor(packedStats: bigint, nStats: number, d1: number): number {
+    if (nStats <= 0 || d1 <= 0) throw new Error('influence: invalid quality divisor')
+    return statsSumSq(packedStats, nStats) / (nStats * d1)
+}