From 51b9bdca11d21e7ee2b670df375c636c2020b286 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Wed, 21 Oct 2026 21:39:25 -0700 Subject: [PATCH 01/23] Compile chalk 5 from a built-in shim with a callable builder class A class whose merged interface carries a call signature stores its call behavior in a '%call' field; calls and function-slot coercions read it. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/shims/chalk/v5.ts | 573 ++++++++++++++++++ packages/compiler/shims/hot-shots/v8.ts | 2 + .../src/frontend/lowering/lower-calls.ts | 25 +- .../compiler/src/frontend/lowering/lowerer.ts | 17 +- .../compiler/src/frontend/package-shims.ts | 49 +- 5 files changed, 657 insertions(+), 9 deletions(-) create mode 100644 packages/compiler/shims/chalk/v5.ts create mode 100644 packages/compiler/shims/hot-shots/v8.ts diff --git a/packages/compiler/shims/chalk/v5.ts b/packages/compiler/shims/chalk/v5.ts new file mode 100644 index 0000000000..6599e35f93 --- /dev/null +++ b/packages/compiler/shims/chalk/v5.ts @@ -0,0 +1,573 @@ +// scriptc's built-in implementation of the `chalk` package, 5.x API. +// +// Programs whose installed chalk is 5.x compile this module in its place +// (packages/compiler/src/frontend/package-shims.ts). chalk builds its +// styles as functions whose prototypes it swaps at run time; here a style +// chain is an instance of one class whose style members are cached +// getters, and the instance is callable through its `%call` field (the +// merged interface below gives it chalk's call signature; the lowerer calls +// the field). The output, color-level detection (supports-color 10: +// FORCE_COLOR, the --color/--no-color flags, TTY, TERM, CI variables) and +// the shared, settable `level` follow chalk 5.6 byte for byte. +import * as os from "node:os"; +import * as tty from "node:tty"; + +export type ColorSupportLevel = 0 | 1 | 2 | 3; + +export interface ColorSupport { + level: ColorSupportLevel; + hasBasic: boolean; + has256: boolean; + has16m: boolean; +} + +export type ColorInfo = ColorSupport | false; + +export interface Options { + readonly level?: ColorSupportLevel; +} + +export type ModifierName = + | "reset" + | "bold" + | "dim" + | "italic" + | "underline" + | "overline" + | "inverse" + | "hidden" + | "strikethrough"; + +export type ForegroundColorName = + | "black" + | "red" + | "green" + | "yellow" + | "blue" + | "cyan" + | "magenta" + | "white" + | "gray" + | "grey" + | "blackBright" + | "redBright" + | "greenBright" + | "yellowBright" + | "blueBright" + | "cyanBright" + | "magentaBright" + | "whiteBright"; + +export type BackgroundColorName = + | "bgBlack" + | "bgRed" + | "bgGreen" + | "bgYellow" + | "bgBlue" + | "bgCyan" + | "bgMagenta" + | "bgWhite" + | "bgGray" + | "bgGrey" + | "bgBlackBright" + | "bgRedBright" + | "bgGreenBright" + | "bgYellowBright" + | "bgBlueBright" + | "bgCyanBright" + | "bgMagentaBright" + | "bgWhiteBright"; + +export type ColorName = ForegroundColorName | BackgroundColorName; + +export type Modifiers = ModifierName; +export type ForegroundColor = ForegroundColorName; +export type BackgroundColor = BackgroundColorName; +export type Color = ColorName; + +// ── ansi-styles ────────────────────────────────────────────────────────── + +export const modifierNames: ModifierName[] = [ + "reset", + "bold", + "dim", + "italic", + "underline", + "overline", + "inverse", + "hidden", + "strikethrough", +]; +export const foregroundColorNames: ForegroundColorName[] = [ + "black", + "red", + "green", + "yellow", + "blue", + "magenta", + "cyan", + "white", + "blackBright", + "gray", + "grey", + "redBright", + "greenBright", + "yellowBright", + "blueBright", + "magentaBright", + "cyanBright", + "whiteBright", +]; +export const backgroundColorNames: BackgroundColorName[] = [ + "bgBlack", + "bgRed", + "bgGreen", + "bgYellow", + "bgBlue", + "bgMagenta", + "bgCyan", + "bgWhite", + "bgBlackBright", + "bgGray", + "bgGrey", + "bgRedBright", + "bgGreenBright", + "bgYellowBright", + "bgBlueBright", + "bgMagentaBright", + "bgCyanBright", + "bgWhiteBright", +]; +export const colorNames: ColorName[] = [ + ...foregroundColorNames, + ...backgroundColorNames, +]; +export const modifiers: Modifiers[] = modifierNames; +export const foregroundColors: ForegroundColor[] = foregroundColorNames; +export const backgroundColors: BackgroundColor[] = backgroundColorNames; +export const colors: Color[] = colorNames; + +const ESC = "\u001B["; + +/** Open and close codes, indexed by style id (the order of the getters). */ +const OPEN_CODES: number[] = [ + 0, 1, 2, 3, 4, 53, 7, 8, 9, + 30, 31, 32, 33, 34, 35, 36, 37, 90, 90, 90, 91, 92, 93, 94, 95, 96, 97, + 40, 41, 42, 43, 44, 45, 46, 47, 100, 100, 100, 101, 102, 103, 104, 105, 106, 107, +]; +const CLOSE_CODES: number[] = [ + 0, 22, 22, 23, 24, 55, 27, 28, 29, + 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, + 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, +]; +const VISIBLE = 45; + +function rgbToAnsi256(red: number, green: number, blue: number): number { + if (red === green && green === blue) { + if (red < 8) return 16; + if (red > 248) return 231; + return Math.round(((red - 8) / 247) * 24) + 232; + } + return ( + 16 + + 36 * Math.round((red / 255) * 5) + + 6 * Math.round((green / 255) * 5) + + Math.round((blue / 255) * 5) + ); +} + +function hexToRgb(hex: string): number[] { + const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex); + if (matches === null) return [0, 0, 0]; + let colorString = matches[0]; + if (colorString.length === 3) { + let doubled = ""; + for (const character of colorString) doubled += character + character; + colorString = doubled; + } + const integer = Number.parseInt(colorString, 16); + return [(integer >> 16) & 0xff, (integer >> 8) & 0xff, integer & 0xff]; +} + +function ansi256ToAnsi(code: number): number { + if (code < 8) return 30 + code; + if (code < 16) return 90 + (code - 8); + let red: number; + let green: number; + let blue: number; + if (code >= 232) { + red = ((code - 232) * 10 + 8) / 255; + green = red; + blue = red; + } else { + code -= 16; + const remainder = code % 36; + red = Math.floor(code / 36) / 5; + green = Math.floor(remainder / 6) / 5; + blue = (remainder % 6) / 5; + } + const value = Math.max(red, green, blue) * 2; + if (value === 0) return 30; + let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red)); + if (value === 2) result += 60; + return result; +} + +/** The open code of a color model at a level: offset 0 is the foreground, + * 10 the background (ansi-styles' wrapAnsi16/256/16m). */ +function rgbOpen(level: number, offset: number, red: number, green: number, blue: number): string { + if (level === 3) return `${ESC}${38 + offset};2;${red};${green};${blue}m`; + if (level === 2) return `${ESC}${38 + offset};5;${rgbToAnsi256(red, green, blue)}m`; + return `${ESC}${ansi256ToAnsi(rgbToAnsi256(red, green, blue)) + offset}m`; +} + +/** chalk's ansi256 model emits the 256-color code at every level (only + * the rgb and hex models downsample). */ +function ansi256Open(offset: number, code: number): string { + return `${ESC}${38 + offset};5;${code}m`; +} + +// ── supports-color ─────────────────────────────────────────────────────── + +function hasFlag(flag: string): boolean { + const argv = process.argv; + const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--"; + const position = argv.indexOf(prefix + flag); + const terminatorPosition = argv.indexOf("--"); + return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); +} + +let flagForceColor: number | undefined = undefined; +if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) { + flagForceColor = 0; +} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) { + flagForceColor = 1; +} + +function envForceColor(): number | undefined { + const force = process.env["FORCE_COLOR"]; + if (force !== undefined) { + if (force === "true") return 1; + if (force === "false") return 0; + return force.length === 0 ? 1 : Math.min(Number.parseInt(force, 10), 3); + } + return undefined; +} + +function translateLevel(level: number): ColorInfo { + if (level === 0) return false; + return { + level: level as ColorSupportLevel, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3, + }; +} + +function inEnv(name: string): boolean { + return process.env[name] !== undefined; +} + +function detectLevel(streamIsTTY: boolean): number { + const noFlagForceColor = envForceColor(); + if (noFlagForceColor !== undefined) flagForceColor = noFlagForceColor; + const forceColor = flagForceColor; + if (forceColor === 0) return 0; + if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3; + if (hasFlag("color=256")) return 2; + if (inEnv("TF_BUILD") && inEnv("AGENT_NAME")) return 1; + if (!streamIsTTY && forceColor === undefined) return 0; + const min = forceColor === undefined || forceColor === 0 || Number.isNaN(forceColor) ? 0 : forceColor; + const env = process.env; + const term = env["TERM"]; + if (term === "dumb") return min; + if (process.platform === "win32") { + const osRelease = os.release().split("."); + if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10_586) { + return Number(osRelease[2]) >= 14_931 ? 3 : 2; + } + return 1; + } + if (inEnv("CI")) { + if (inEnv("GITHUB_ACTIONS") || inEnv("GITEA_ACTIONS") || inEnv("CIRCLECI")) return 3; + if ( + inEnv("TRAVIS") || + inEnv("APPVEYOR") || + inEnv("GITLAB_CI") || + inEnv("BUILDKITE") || + inEnv("DRONE") || + env["CI_NAME"] === "codeship" + ) { + return 1; + } + return min; + } + const teamcity = env["TEAMCITY_VERSION"]; + if (teamcity !== undefined) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(teamcity) ? 1 : 0; + } + if (env["COLORTERM"] === "truecolor") return 3; + if (term === "xterm-kitty") return 3; + if (term === "xterm-ghostty") return 3; + if (term === "wezterm") return 3; + const termProgram = env["TERM_PROGRAM"]; + if (termProgram !== undefined) { + const version = Number.parseInt((env["TERM_PROGRAM_VERSION"] || "").split(".")[0]!, 10); + if (termProgram === "iTerm.app") return version >= 3 ? 3 : 2; + if (termProgram === "Apple_Terminal") return 2; + } + // supports-color tests these against `env.TERM`, which is the string + // "undefined" when TERM is unset. + const termText = term === undefined ? "undefined" : term; + if (/-256(color)?$/i.test(termText)) return 2; + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(termText)) return 1; + if (inEnv("COLORTERM")) return 1; + return min; +} + +const stdoutColor: ColorInfo = translateLevel(detectLevel(tty.isatty(1))); +const stderrColor: ColorInfo = translateLevel(detectLevel(tty.isatty(2))); + +export const supportsColor: ColorInfo = stdoutColor; +export const supportsColorStderr: ColorInfo = stderrColor; + +// ── the builder ────────────────────────────────────────────────────────── + +/** One link of a style chain (chalk's styler). */ +class Styler { + open: string; + close: string; + openAll: string; + closeAll: string; + parent: Styler | undefined; + constructor(open: string, close: string, parent: Styler | undefined) { + this.open = open; + this.close = close; + this.parent = parent; + if (parent === undefined) { + this.openAll = open; + this.closeAll = close; + } else { + this.openAll = parent.openAll + open; + this.closeAll = close + parent.closeAll; + } + } +} + +/** The level every builder of one chalk instance shares. */ +class LevelBox { + level: number; + constructor(level: number) { + this.level = level; + } +} + +function stringReplaceAll(string: string, substring: string, replacer: string): string { + let index = string.indexOf(substring); + if (index === -1) return string; + const substringLength = substring.length; + let endIndex = 0; + let returnValue = ""; + do { + returnValue += string.slice(endIndex, index) + substring + replacer; + endIndex = index + substringLength; + index = string.indexOf(substring, endIndex); + } while (index !== -1); + returnValue += string.slice(endIndex); + return returnValue; +} + +function stringEncaseCRLFWithFirstIndex( + string: string, + prefix: string, + postfix: string, + index: number, +): string { + let endIndex = 0; + let returnValue = ""; + do { + const gotCR = string[index - 1] === "\r"; + returnValue += + string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix; + endIndex = index + 1; + index = string.indexOf("\n", endIndex); + } while (index !== -1); + returnValue += string.slice(endIndex); + return returnValue; +} + +function applyStyle(self: ChalkInstance, string: string): string { + if (self.box.level <= 0 || !string) return self.isEmpty ? "" : string; + let styler = self.styler; + if (styler === undefined) return string; + const openAll = styler.openAll; + const closeAll = styler.closeAll; + if (string.includes("\u001B")) { + while (styler !== undefined) { + string = stringReplaceAll(string, styler.close, styler.open); + styler = styler.parent; + } + } + const lfIndex = string.indexOf("\n"); + if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex); + return openAll + string + closeAll; +} + +function joinArguments(args: unknown[]): string { + let out = ""; + for (let i = 0; i < args.length; i++) { + if (i > 0) out += " "; + const value = args[i]; + if (value !== undefined && value !== null) out += String(value); + } + return out; +} + +/** A chalk instance or one of its style chains: callable (chalk's call + * signature merges in from the interface), with every style a cached + * getter. */ +export interface ChalkInstance { + (...text: unknown[]): string; +} + +export class ChalkInstance { + "%call": (...text: unknown[]) => string; + box: LevelBox; + styler: Styler | undefined; + isEmpty: boolean; + private readonly cache: (ChalkInstance | undefined)[] = []; + + constructor(box: LevelBox, styler: Styler | undefined, isEmpty: boolean, root: boolean) { + this.box = box; + this.styler = styler; + this.isEmpty = isEmpty; + // One unconditional store: the field's definite assignment. + this["%call"] = (...text: unknown[]): string => + root + ? joinArguments(text) + : applyStyle(this, text.length === 1 ? "" + String(text[0]) : joinArguments(text)); + } + + get level(): ColorSupportLevel { + return this.box.level as ColorSupportLevel; + } + + set level(level: ColorSupportLevel) { + this.box.level = level; + } + + private style(id: number): ChalkInstance { + const cached = this.cache[id]; + if (cached !== undefined) return cached; + let builder: ChalkInstance; + if (id === VISIBLE) { + builder = new ChalkInstance(this.box, this.styler, true, false); + } else { + const styler = new Styler( + `${ESC}${OPEN_CODES[id]!}m`, + `${ESC}${CLOSE_CODES[id]!}m`, + this.styler, + ); + builder = new ChalkInstance(this.box, styler, this.isEmpty, false); + } + while (this.cache.length <= id) this.cache.push(undefined); + this.cache[id] = builder; + return builder; + } + + private model(open: string, background: boolean): ChalkInstance { + const styler = new Styler(open, background ? `${ESC}49m` : `${ESC}39m`, this.styler); + return new ChalkInstance(this.box, styler, this.isEmpty, false); + } + + rgb(red: number, green: number, blue: number): ChalkInstance { + return this.model(rgbOpen(this.box.level, 0, red, green, blue), false); + } + hex(color: string): ChalkInstance { + const [red, green, blue] = hexToRgb(color); + return this.model(rgbOpen(this.box.level, 0, red!, green!, blue!), false); + } + ansi256(index: number): ChalkInstance { + return this.model(ansi256Open(0, index), false); + } + bgRgb(red: number, green: number, blue: number): ChalkInstance { + return this.model(rgbOpen(this.box.level, 10, red, green, blue), true); + } + bgHex(color: string): ChalkInstance { + const [red, green, blue] = hexToRgb(color); + return this.model(rgbOpen(this.box.level, 10, red!, green!, blue!), true); + } + bgAnsi256(index: number): ChalkInstance { + return this.model(ansi256Open(10, index), true); + } + + get reset(): ChalkInstance { return this.style(0); } + get bold(): ChalkInstance { return this.style(1); } + get dim(): ChalkInstance { return this.style(2); } + get italic(): ChalkInstance { return this.style(3); } + get underline(): ChalkInstance { return this.style(4); } + get overline(): ChalkInstance { return this.style(5); } + get inverse(): ChalkInstance { return this.style(6); } + get hidden(): ChalkInstance { return this.style(7); } + get strikethrough(): ChalkInstance { return this.style(8); } + get visible(): ChalkInstance { return this.style(VISIBLE); } + get black(): ChalkInstance { return this.style(9); } + get red(): ChalkInstance { return this.style(10); } + get green(): ChalkInstance { return this.style(11); } + get yellow(): ChalkInstance { return this.style(12); } + get blue(): ChalkInstance { return this.style(13); } + get magenta(): ChalkInstance { return this.style(14); } + get cyan(): ChalkInstance { return this.style(15); } + get white(): ChalkInstance { return this.style(16); } + get blackBright(): ChalkInstance { return this.style(17); } + get gray(): ChalkInstance { return this.style(18); } + get grey(): ChalkInstance { return this.style(19); } + get redBright(): ChalkInstance { return this.style(20); } + get greenBright(): ChalkInstance { return this.style(21); } + get yellowBright(): ChalkInstance { return this.style(22); } + get blueBright(): ChalkInstance { return this.style(23); } + get magentaBright(): ChalkInstance { return this.style(24); } + get cyanBright(): ChalkInstance { return this.style(25); } + get whiteBright(): ChalkInstance { return this.style(26); } + get bgBlack(): ChalkInstance { return this.style(27); } + get bgRed(): ChalkInstance { return this.style(28); } + get bgGreen(): ChalkInstance { return this.style(29); } + get bgYellow(): ChalkInstance { return this.style(30); } + get bgBlue(): ChalkInstance { return this.style(31); } + get bgMagenta(): ChalkInstance { return this.style(32); } + get bgCyan(): ChalkInstance { return this.style(33); } + get bgWhite(): ChalkInstance { return this.style(34); } + get bgBlackBright(): ChalkInstance { return this.style(35); } + get bgGray(): ChalkInstance { return this.style(36); } + get bgGrey(): ChalkInstance { return this.style(37); } + get bgRedBright(): ChalkInstance { return this.style(38); } + get bgGreenBright(): ChalkInstance { return this.style(39); } + get bgYellowBright(): ChalkInstance { return this.style(40); } + get bgBlueBright(): ChalkInstance { return this.style(41); } + get bgMagentaBright(): ChalkInstance { return this.style(42); } + get bgCyanBright(): ChalkInstance { return this.style(43); } + get bgWhiteBright(): ChalkInstance { return this.style(44); } +} + +function optionsLevel(options: Options | undefined): number { + const level = options === undefined ? undefined : options.level; + if (level !== undefined && level !== 0 && !(Number.isInteger(level) && level >= 0 && level <= 3)) { + throw new Error("The `level` option should be an integer from 0 to 3"); + } + if (level === undefined) return stdoutColor === false ? 0 : stdoutColor.level; + return level; +} + +/** `new Chalk(options)`: a fresh chalk instance with its own level. */ +export class Chalk extends ChalkInstance { + constructor(options?: Options) { + super(new LevelBox(optionsLevel(options)), undefined, false, true); + } +} + +const chalk: ChalkInstance = new Chalk(); +export const chalkStderr: ChalkInstance = new Chalk({ + level: stderrColor === false ? 0 : stderrColor.level, +}); + +export default chalk; diff --git a/packages/compiler/shims/hot-shots/v8.ts b/packages/compiler/shims/hot-shots/v8.ts new file mode 100644 index 0000000000..2c036408ea --- /dev/null +++ b/packages/compiler/shims/hot-shots/v8.ts @@ -0,0 +1,2 @@ +export class StatsD {} +export default StatsD; diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 39b7207c03..53971c7b02 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -1619,7 +1619,13 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr { } const accessorTarget = lowerer.fieldTarget(expr.expression); if (accessorTarget?.container === "accessor") { - const callee = lowerer.fieldGetExpr(accessorTarget, locOf(expr.expression), expr.expression); + let callee = lowerer.fieldGetExpr(accessorTarget, locOf(expr.expression), expr.expression); + // A getter returning a callable class instance (chalk's + // `chalk.red("x")`): call through its `%call` field. + if (callee.type.kind === "object") { + callee = lowerer.hybridCallUnwrap(callee); + if (callee.type.kind === "func") return lowerCallThroughValue(lowerer, expr, callee, locOf(expr)); + } if (callee.type.kind === "func") { const args = completeFuncValueArgs(lowerer, expr, callee.type, locOf(expr)); return { kind: "callValue", callee, args, type: callee.type.ret, loc: locOf(expr) }; @@ -1871,7 +1877,19 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr { // a non-func IR type was already rejected while lowering the callee. // HYBRID (function-with-properties) values call through their %call slot. let callee = lowerer.lowerExpr(expr.expression); - if (callee.type.kind === "record") callee = lowerer.hybridCallUnwrap(callee); + if (callee.type.kind === "record" || callee.type.kind === "object") + callee = lowerer.hybridCallUnwrap(callee); + return lowerCallThroughValue(lowerer, expr, callee, loc); +} + +/** A call through an evaluated callee value: checked-dynamic callees, + * function unions, typed-rest and runtime-arity closures. */ +function lowerCallThroughValue( + lowerer: Lowerer, + expr: ts.CallExpression, + callee: IrExpr, + loc: SrcLoc, +): IrExpr { // A CHECKED-DYNAMIC callee — `fn(a, b)` where fn is an implicit-any // JS binding (the mustCall body's `fn(...args)`), a dyn capture, or a // keyed read off a dyn value: the dynCall boundary. Arguments convert @@ -9181,7 +9199,8 @@ export function lowerRecordFieldCall( // A HYBRID (function-with-properties) field is callable through its // reserved %call slot — `colors.blue("x")` where blue also carries // `.bold` (the chalk shape). - if (callee.type.kind === "record") callee = lowerer.hybridCallUnwrap(callee); + if (callee.type.kind === "record" || callee.type.kind === "object") + callee = lowerer.hybridCallUnwrap(callee); // Inferred JavaScript option records can retain checked callables in // fields even when the checker only describes those members as any. // TypeScript reaches here for callable library types that are checked diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index b02a0a843c..b1867be326 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -9294,6 +9294,21 @@ export class Lowerer { * type-mapper.ts's chalk-shape mapping — call paths and func-slot coercions * share it. */ hybridCallUnwrap(expr: IrExpr): IrExpr { + // A callable CLASS instance: a class whose merged interface carries a + // call signature stores its call behavior in a `%call` field (the + // chalk package shim's builder). Calls read the field. + if (expr.type.kind === "object") { + const callType = this.classes.get(expr.type.className)?.fields.get("%call"); + if (callType === undefined || callType.kind !== "func") return expr; + return { + kind: "fieldGet", + obj: expr, + className: expr.type.className, + field: "%call", + type: callType, + loc: expr.loc, + }; + } if (expr.type.kind !== "record") return expr; const shape = this.shapes.get(expr.type.shapeId); const call = shape?.fields.find((f) => f.name === "%call"); @@ -9624,7 +9639,7 @@ export class Lowerer { // A HYBRID (function-with-properties) record flowing into a plain // func slot extracts its reserved %call field — the chalk shape's // "the value IS callable" half (type-mapper.ts's hybrid mapping). - if (expected.kind === "func" && expr.type.kind === "record") { + if (expected.kind === "func" && (expr.type.kind === "record" || expr.type.kind === "object")) { const un = this.hybridCallUnwrap(expr); if (un !== expr && typeEquals(un.type, expected)) return un; } diff --git a/packages/compiler/src/frontend/package-shims.ts b/packages/compiler/src/frontend/package-shims.ts index 86a41d3a68..f9cf1deb67 100644 --- a/packages/compiler/src/frontend/package-shims.ts +++ b/packages/compiler/src/frontend/package-shims.ts @@ -62,6 +62,9 @@ interface ImplementationShim { * of it (a __commonJS chunk whose key names the package, its version * and this file) is the package itself. */ mainFile: string; + /** The package's declaration entry relative to its directory, when it + * is not `index.d.ts`. */ + typesFile?: string; } const IMPLEMENTATION_SHIMS: ReadonlyMap = new Map([ @@ -79,6 +82,26 @@ const IMPLEMENTATION_SHIMS: ReadonlyMap = new Map([ ]), }, ], + [ + "chalk", + { + name: "chalk", + defaultExport: true, + mainFile: "source/index.js", + typesFile: "source/index.d.ts", + versions: new Map([[5, "chalk/v5.ts"]]), + }, + ], + [ + "hot-shots", + { + name: "hot-shots", + defaultExport: true, + mainFile: "index.js", + typesFile: "types.d.ts", + versions: new Map([[8, "hot-shots/v8.ts"]]), + }, + ], [ "undici", { @@ -280,16 +303,32 @@ export function isShimmedImport(fromFile: string, specifier: string): boolean { return isUnloadedPackage(specifier) || packageShimFor(fromFile, specifier) !== null; } +/** The shimmed package whose declaration entry `path` is, with the + * package directory: `/index.d.ts`, or the entry's own `typesFile`. */ +function shimOfDeclarationPath(path: string): { pkgDir: string; shim: ImplementationShim } | null { + if (!path.endsWith(".d.ts")) return null; + if (path.endsWith("/index.d.ts")) { + const pkgDir = dirname(path); + const shim = IMPLEMENTATION_SHIMS.get(pkgDir.slice(pkgDir.lastIndexOf("/") + 1)); + if (shim !== undefined && shim.typesFile === undefined) return { pkgDir, shim }; + } + for (const shim of IMPLEMENTATION_SHIMS.values()) { + if (shim.typesFile === undefined) continue; + const suffix = `/${shim.name}/${shim.typesFile}`; + if (path.endsWith(suffix)) return { pkgDir: path.slice(0, path.length - suffix.length + shim.name.length + 1), shim }; + } + return null; +} + /** The fs-shadow answer for a shimmed package's declaration entry: the * installed `index.d.ts` reads as a re-export of the version's shim module, * so the checker types each importer against its own version. Undefined * for every other path. */ export function packageShimDeclarationText(path: string): string | undefined { - if (!path.endsWith("/index.d.ts")) return undefined; - const pkgDir = dirname(path); - const name = pkgDir.slice(pkgDir.lastIndexOf("/") + 1); - const shim = IMPLEMENTATION_SHIMS.get(name); - if (shim === undefined) return undefined; + const located = shimOfDeclarationPath(path); + if (located === null) return undefined; + const { pkgDir, shim } = located; + const name = shim.name; // A DefinitelyTyped twin (`@types/fs-extra`) types a package that ships no // declarations. Nothing at its path names the installed runtime version, // so it reads as the shim only when every supported version shares one From 750c817649e01371c160e91ee5b5263c671440ef Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Wed, 21 Oct 2026 21:45:50 -0700 Subject: [PATCH 02/23] Compile hot-shots 8 from a built-in typed StatsD shim udp over node:dgram (TypeScript may use the send completion-callback form), tcp over node:net, mock mode, child clients, tags, checks and events; uds reports the missing unix-dgram addon as hot-shots does. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/shims/hot-shots/v8.ts | 952 +++++++++++++++++- .../src/frontend/lowering/lower-dgram.ts | 4 +- 2 files changed, 954 insertions(+), 2 deletions(-) diff --git a/packages/compiler/shims/hot-shots/v8.ts b/packages/compiler/shims/hot-shots/v8.ts index 2c036408ea..a8af7a19ed 100644 --- a/packages/compiler/shims/hot-shots/v8.ts +++ b/packages/compiler/shims/hot-shots/v8.ts @@ -1,2 +1,952 @@ -export class StatsD {} +// scriptc's built-in implementation of the `hot-shots` package, 8.x API. +// +// Programs whose installed hot-shots is 8.x compile this module in its +// place (packages/compiler/src/frontend/package-shims.ts). It is a typed +// port of hot-shots 8.5's StatsD client: the same datagrams, callbacks, +// error messages and child-client sharing, over node:dgram (udp) and +// node:net (tcp). The uds protocol needs the optional `unix-dgram` addon; +// this entry serves programs where it is not installed, so uds reports +// hot-shots' "not installed" error exactly as Node does. +import * as dgram from "node:dgram"; +import * as dns from "node:dns"; +import * as net from "node:net"; +import * as os from "node:os"; + +export type Tags = { [key: string]: string } | string[]; + +export interface ClientOptions { + bufferFlushInterval?: number; + bufferHolder?: { buffer: string }; + cacheDns?: boolean; + cacheDnsTtl?: number; + errorHandler?: (err: Error) => void; + globalTags?: Tags; + globalize?: boolean; + host?: string; + isChild?: boolean; + maxBufferSize?: number; + mock?: boolean; + path?: string; + port?: number; + prefix?: string; + protocol?: "tcp" | "udp" | "uds"; + sampleRate?: number; + suffix?: string; + telegraf?: boolean; + useDefaultRoute?: boolean; + tagPrefix?: string; + tagSeparator?: string; + udsGracefulErrorHandling?: boolean; + udsGracefulRestartRateLimit?: number; + closingFlushInterval?: number; +} + +export interface ChildClientOptions { + globalTags?: Tags; + prefix?: string; + suffix?: string; + errorHandler?: (err: Error) => void; +} + +export interface CheckOptions { + /** A Unix timestamp; hot-shots also takes a Date, which this shim's + * option records cannot hold yet. */ + date_happened?: number; + hostname?: string; + message?: string; +} + +export interface DatadogChecks { + OK: 0; + WARNING: 1; + CRITICAL: 2; + UNKNOWN: 3; +} + +export type DatadogChecksValues = 0 | 1 | 2 | 3; + +export interface EventOptions { + aggregation_key?: string; + alert_type?: "info" | "warning" | "success" | "error"; + /** A Unix timestamp; hot-shots also takes a Date, which this shim's + * option records cannot hold yet. */ + date_happened?: number; + hostname?: string; + priority?: "low" | "normal"; + source_type_name?: string; +} + +/** A send's completion: hot-shots passes `null` on success. */ +export type StatsCb = (error: Error | null | undefined, bytes?: any) => void; + +type SampleArg = number | Tags | StatsCb | undefined; +type TagsArg = Tags | StatsCb | undefined; + +const PROTOCOL_TCP = "tcp"; +const PROTOCOL_UDS = "uds"; +const PROTOCOL_UDP = "udp"; +const UDS_DEFAULT_GRACEFUL_RESTART_LIMIT = 1000; +const CACHE_DNS_TTL_DEFAULT = 60000; + +function udsErrorCodes(): number[] { + if (process.platform === "linux") { + return [os.constants.errno.ENOTCONN, os.constants.errno.ECONNREFUSED]; + } + if (process.platform === "darwin") { + return [os.constants.errno.EDESTADDRREQ, os.constants.errno.ECONNRESET]; + } + return []; +} +const UDS_ERROR_CODES = udsErrorCodes(); + +// ── helpers ────────────────────────────────────────────────────────────── + +function sanitizeTags(value: string, telegraf: boolean): string { + const blacklist = telegraf ? /:|\||,/g : /:|\||@|,/g; + return String(value).replace(blacklist, "_"); +} + +function formatTags(tags: Tags, telegraf: boolean): string[] { + if (Array.isArray(tags)) return tags; + const out: string[] = []; + for (const key of Object.keys(tags)) { + out.push(`${sanitizeTags(key, telegraf)}:${sanitizeTags(tags[key]!, telegraf)}`); + } + return out; +} + +function isArrayIndexKey(key: string): boolean { + return /^(0|[1-9]\d*)$/.test(key) && Number(key) < 4294967295; +} + +function overrideTags(parent: string[], child: Tags, telegraf: boolean): string[] { + const childKeys: string[] = []; + const childValues = new Map(); + const toAppend: string[] = []; + for (const tag of formatTags(child, telegraf)) { + const idx = tag.indexOf(":"); + if (idx < 1) { + toAppend.push(tag); + } else { + const key = tag.substring(0, idx); + const value = tag.substring(idx + 1); + let values = childValues.get(key); + if (values === undefined) { + values = []; + childValues.set(key, values); + childKeys.push(key); + } + values.push(value); + } + } + const result = parent.filter((tag) => { + const idx = tag.indexOf(":"); + if (idx < 1) return true; + return !childValues.has(tag.substring(0, idx)); + }); + // hot-shots walks an object's keys: array-index keys ascending first, + // then the rest in insertion order. + const indexKeys = childKeys.filter(isArrayIndexKey).sort((a, b) => Number(a) - Number(b)); + const ordered = indexKeys.concat(childKeys.filter((key) => !isArrayIndexKey(key))); + for (const key of ordered) { + for (const value of childValues.get(key)!) result.push(`${key}:${value}`); + } + return result.concat(toAppend); +} + +function formatDate(date: number): number { + return Math.round(date); +} + +function errorWithCode(message: string, code: string | undefined): Error { + const error: NodeJS.ErrnoException = new Error(message); + error.code = code; + return error; +} + +// ── transports ─────────────────────────────────────────────────────────── + +type SendCallback = (err: Error | null, bytes?: number) => void; + +/** The socket a client sends through (hot-shots' transport interface). */ +interface Transport { + createdAt: number; + send(buf: Buffer, callback: SendCallback): void; + close(): void; + onError(listener: (err: Error) => void): void; + offError(listener: (err: Error) => void): void; + onClose(listener: () => void): void; +} + +/** A socket's 'error' listeners, kept by the transport (the typed + * sockets have no removeListener): one socket listener dispatches to a + * snapshot, and an error nobody listens for throws, as an unhandled + * 'error' event does. */ +class ErrorListeners { + private listeners: ((err: Error) => void)[] = []; + add(listener: (err: Error) => void): void { + this.listeners.push(listener); + } + remove(listener: (err: Error) => void): void { + const index = this.listeners.indexOf(listener); + if (index !== -1) this.listeners.splice(index, 1); + } + emit(err: Error): void { + const snapshot = this.listeners.slice(); + if (snapshot.length === 0) throw err; + for (const listener of snapshot) listener(err); + } +} + +function addEol(buf: Buffer): string { + let msg = buf.toString(); + if (msg.length > 0 && msg[msg.length - 1] !== "\n") msg += "\n"; + return msg; +} + +class UdpTransport implements Transport { + createdAt = 0; + private readonly socket: dgram.Socket; + private readonly errors = new ErrorListeners(); + private resolvedAddress: string | undefined = undefined; + private resolvedAt = 0; + private readonly host: string | undefined; + private readonly port: number; + private readonly cacheDns: boolean; + private readonly cacheDnsTtl: number; + constructor(host: string | undefined, port: number, cacheDns: boolean, cacheDnsTtl: number) { + this.host = host; + this.port = port; + this.cacheDns = cacheDns; + this.cacheDnsTtl = cacheDnsTtl; + this.socket = dgram.createSocket("udp4"); + this.socket.unref(); + this.socket.on("error", (err) => this.errors.emit(err)); + } + send(buf: Buffer, callback: SendCallback): void { + if (!this.cacheDns) { + this.socket.send(buf, this.port, this.host || "127.0.0.1", callback); + return; + } + const now = Date.now(); + const cached = this.resolvedAddress; + if (cached === undefined || now - this.resolvedAt > this.cacheDnsTtl) { + dns.lookup(this.host ?? "localhost", (error, address) => { + if (error) { + callback(error); + return; + } + this.resolvedAddress = address; + this.resolvedAt = now; + this.socket.send(buf, this.port, address, callback); + }); + } else { + this.socket.send(buf, this.port, cached, callback); + } + } + close(): void { + this.socket.close(); + } + onError(listener: (err: Error) => void): void { + this.errors.add(listener); + } + offError(listener: (err: Error) => void): void { + this.errors.remove(listener); + } + onClose(listener: () => void): void { + this.socket.on("close", listener); + } +} + +class TcpTransport implements Transport { + createdAt = 0; + private readonly socket: net.Socket; + private readonly errors = new ErrorListeners(); + constructor(host: string | undefined, port: number) { + this.socket = net.connect(port, host ?? "localhost"); + this.socket.setKeepAlive(true); + this.socket.unref(); + this.socket.on("error", (err) => this.errors.emit(err)); + } + send(buf: Buffer, callback: SendCallback): void { + // The typed socket's write takes the data alone; the completion runs + // on the next tick. + this.socket.write(addEol(buf)); + process.nextTick(() => callback(null)); + } + close(): void { + this.socket.destroy(); + } + onError(listener: (err: Error) => void): void { + this.errors.add(listener); + } + offError(listener: (err: Error) => void): void { + this.errors.remove(listener); + } + onClose(listener: () => void): void { + this.socket.on("close", () => listener()); + } +} + +/** hot-shots reaches Unix datagram sockets through the optional + * `unix-dgram` addon; this entry serves programs without it. */ +function createUdsTransport(): Transport { + throw new Error( + "The library `unix_dgram`, needed for the uds protocol to work, is not installed. " + + "You need to pick another protocol to use hot-shots. " + + "See the hot-shots README for additional details.", + ); +} + +function createTransport(client: StatsD): Transport | null { + let transport: Transport | null = null; + const protocol = client.protocol; + try { + if (protocol === PROTOCOL_TCP) { + transport = new TcpTransport(client.host, client.port); + } else if (protocol === PROTOCOL_UDS) { + transport = createUdsTransport(); + } else if (protocol === PROTOCOL_UDP) { + transport = new UdpTransport(client.host, client.port, client.cacheDns, client.cacheDnsTtl); + } else { + throw new Error(`Unsupported protocol '${protocol}'`); + } + transport.createdAt = Date.now(); + } catch (e) { + const handler = client.errorHandler; + if (handler) { + handler(e as Error); + } else { + console.error(e); + } + } + return transport; +} + +// ── the client ─────────────────────────────────────────────────────────── + +class BufferHolder { + buffer = ""; +} + +/** What a child client inherits from its parent. */ +class ChildInit { + socket: Transport | null; + bufferHolder: BufferHolder; + dnsError: Error | undefined; + constructor(socket: Transport | null, bufferHolder: BufferHolder, dnsError: Error | undefined) { + this.socket = socket; + this.bufferHolder = bufferHolder; + this.dnsError = dnsError; + } +} + +export class StatsD { + protocol: string; + cacheDns: boolean; + cacheDnsTtl: number; + host: string | undefined; + port: number; + path: string | undefined; + prefix: string; + suffix: string; + tagPrefix: string; + tagSeparator: string; + mock: boolean; + globalTags: string[]; + telegraf: boolean; + maxBufferSize: number; + sampleRate: number; + bufferFlushInterval: number; + errorHandler: ((err: Error) => void) | undefined; + udsGracefulErrorHandling: boolean; + udsGracefulRestartRateLimit: number; + isChild: boolean; + closingFlushInterval: number; + mockBuffer: string[] | undefined = undefined; + messagesInFlight = 0; + CHECKS: DatadogChecks = { OK: 0, WARNING: 1, CRITICAL: 2, UNKNOWN: 3 }; + private bufferHolder: BufferHolder; + private transport: Transport | null = null; + private dnsError: Error | undefined = undefined; + private stopFlushInterval: (() => void) | undefined = undefined; + + constructor(options?: ClientOptions, child?: ChildInit) { + const o: ClientOptions = options ?? {}; + const protocol = o.protocol ? o.protocol.toLowerCase() : ""; + this.protocol = protocol ? protocol : PROTOCOL_UDP; + this.cacheDns = o.cacheDns === true; + this.cacheDnsTtl = o.cacheDnsTtl || CACHE_DNS_TTL_DEFAULT; + this.host = o.host || process.env["DD_AGENT_HOST"]; + this.port = o.port || parseInt(process.env["DD_DOGSTATSD_PORT"] ?? "", 10) || 8125; + this.path = o.path; + this.prefix = o.prefix || ""; + this.suffix = o.suffix || ""; + this.tagPrefix = o.tagPrefix || "#"; + this.tagSeparator = o.tagSeparator || ","; + this.mock = o.mock === true; + this.telegraf = o.telegraf || false; + const globalTags = o.globalTags; + this.globalTags = globalTags !== undefined ? formatTags(globalTags, this.telegraf) : []; + const entityId = process.env["DD_ENTITY_ID"]; + if (entityId) { + this.globalTags = this.globalTags.filter( + (item) => item.indexOf("dd.internal.entity_id:") !== 0, + ); + this.globalTags.push("dd.internal.entity_id:".concat(sanitizeTags(entityId, false))); + } + this.maxBufferSize = o.maxBufferSize || 0; + this.sampleRate = o.sampleRate || 1; + this.bufferFlushInterval = o.bufferFlushInterval || 1000; + this.bufferHolder = child !== undefined ? child.bufferHolder : new BufferHolder(); + this.errorHandler = o.errorHandler; + const graceful = o.udsGracefulErrorHandling; + this.udsGracefulErrorHandling = graceful === undefined ? true : graceful; + this.udsGracefulRestartRateLimit = + o.udsGracefulRestartRateLimit || UDS_DEFAULT_GRACEFUL_RESTART_LIMIT; + this.isChild = child !== undefined; + this.closingFlushInterval = o.closingFlushInterval || 50; + if (this.mock) this.mockBuffer = []; + if (child === undefined && this.maxBufferSize > 0) { + const handle = setInterval(() => this.onBufferFlushInterval(), this.bufferFlushInterval); + handle.unref(); + this.stopFlushInterval = () => clearInterval(handle); + } + if (child !== undefined) { + if (child.dnsError) this.dnsError = child.dnsError; + this.transport = child.socket; + } + if (!this.transport) this.transport = createTransport(this); + const handler = o.errorHandler; + const transport = this.transport; + if (transport !== null && child === undefined && handler) transport.onError(handler); + if (transport !== null && o.protocol === PROTOCOL_UDS) this.maybeAddUDSErrorHandler(); + } + + private maybeAddUDSErrorHandler(): void { + if (this.isChild || !this.udsGracefulErrorHandling) return; + const transport = this.transport; + if (transport !== null) transport.onError((err) => this.udsErrorHandler(err)); + } + + private udsErrorHandler(err: Error): void { + const code = Number((err as NodeJS.ErrnoException).code); + if (!UDS_ERROR_CODES.includes(-code)) return; + const socket = this.transport; + if (socket === null) return; + if (!socket.createdAt || Date.now() - socket.createdAt < this.udsGracefulRestartRateLimit) { + return; + } + const handler = this.errorHandler; + if (handler) socket.offError(handler); + const newSocket = createTransport(this); + if (newSocket === null) { + const errorMessage = "Could not replace UDS connection with new socket"; + if (handler) { + handler(new Error(errorMessage)); + } else { + console.error(errorMessage); + } + return; + } + socket.close(); + this.transport = newSocket; + this.maybeAddUDSErrorHandler(); + if (handler) { + newSocket.onError(handler); + } else { + newSocket.onError((error) => console.error(`hot-shots UDS error: ${String(error)}`)); + } + } + + // ── stats functions ── + + timing(stat: string | string[], time: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + timing(stat: string | string[], time: number, tags?: Tags, callback?: StatsCb): void; + timing(stat: string | string[], time: number, callback?: StatsCb): void; + timing(stat: string | string[], time: number, sampleRate?: number, callback?: StatsCb): void; + timing( + stat: string | string[], + time: number, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, time, "ms", sampleRate, tags, callback); + } + + increment(stat: string, tags?: Tags): void; + increment(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + increment(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + increment(stat: string | string[], value: number, callback?: StatsCb): void; + increment(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + increment( + stat: string | string[], + value?: number | Tags, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + // A non-number second argument of a two-argument call is the tags. + let amount = 1; + let tagArg: TagsArg = tags; + if (typeof value === "number") { + amount = value; + } else if (sampleRate === undefined && tags === undefined && callback === undefined) { + tagArg = value; + } + this.sendAll(stat, amount, "c", sampleRate, tagArg, callback); + } + + decrement(stat: string, tags?: Tags): void; + decrement(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + decrement(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + decrement(stat: string | string[], value: number, callback?: StatsCb): void; + decrement(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + decrement( + stat: string | string[], + value?: number | Tags, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + let amount = 1; + let tagArg: TagsArg = tags; + if (typeof value === "number") { + amount = value; + } else if (sampleRate === undefined && tags === undefined && callback === undefined) { + tagArg = value; + } + this.sendAll(stat, -amount, "c", sampleRate, tagArg, callback); + } + + histogram(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + histogram(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + histogram(stat: string | string[], value: number, callback?: StatsCb): void; + histogram(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + histogram( + stat: string | string[], + value: number, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "h", sampleRate, tags, callback); + } + + distribution(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + distribution(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + distribution(stat: string | string[], value: number, callback?: StatsCb): void; + distribution(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + distribution( + stat: string | string[], + value: number, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "d", sampleRate, tags, callback); + } + + gauge(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + gauge(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + gauge(stat: string | string[], value: number, callback?: StatsCb): void; + gauge(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + gauge( + stat: string | string[], + value: number, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "g", sampleRate, tags, callback); + } + + set(stat: string | string[], value: number | string, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + set(stat: string | string[], value: number | string, tags?: Tags, callback?: StatsCb): void; + set(stat: string | string[], value: number | string, callback?: StatsCb): void; + set(stat: string | string[], value: number | string, sampleRate?: number, callback?: StatsCb): void; + set( + stat: string | string[], + value: number | string, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "s", sampleRate, tags, callback); + } + + unique(stat: string | string[], value: number | string, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + unique(stat: string | string[], value: number | string, tags?: Tags, callback?: StatsCb): void; + unique(stat: string | string[], value: number | string, callback?: StatsCb): void; + unique(stat: string | string[], value: number | string, sampleRate?: number, callback?: StatsCb): void; + unique( + stat: string | string[], + value: number | string, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "s", sampleRate, tags, callback); + } + + check( + name: string, + status: DatadogChecksValues, + options?: CheckOptions, + tags?: Tags | StatsCb, + callback?: StatsCb, + ): void { + if (this.telegraf) { + const err = new Error("Not supported by Telegraf / InfluxDB"); + if (callback) return callback(err); + const handler = this.errorHandler; + if (handler) return handler(err); + throw err; + } + const check: string[] = ["_sc", this.prefix + name + this.suffix, String(status)]; + const metadata: CheckOptions = options ?? {}; + const happened = metadata.date_happened; + if (happened) { + const timestamp = formatDate(happened); + if (timestamp) check.push(`d:${timestamp}`); + } + if (metadata.hostname) check.push(`h:${metadata.hostname}`); + let mergedTags = this.globalTags; + if (tags !== undefined && typeof tags !== "function") { + mergedTags = overrideTags(mergedTags, tags, this.telegraf); + } + if (mergedTags.length > 0) check.push(`#${mergedTags.join(",")}`); + if (metadata.message) check.push(`m:${metadata.message}`); + let cb = callback; + if (typeof tags === "function" && callback === undefined) cb = tags; + this.sendRaw(check.join("|"), cb); + } + + event( + title: string, + text?: string, + options?: EventOptions, + tags?: Tags | StatsCb, + callback?: StatsCb, + ): void { + if (this.telegraf) { + const err = new Error("Not supported by Telegraf / InfluxDB"); + if (callback) return callback(err); + const handler = this.errorHandler; + if (handler) return handler(err); + throw err; + } + const msgTitle = String(title ? title : ""); + let msgText = String(text ? text : msgTitle); + msgText = msgText.replace(/\n/g, "\\n"); + let message = `_e{${msgTitle.length},${msgText.length}}:${msgTitle}|${msgText}`; + if (options) { + const happened = options.date_happened; + if (happened) { + const timestamp = formatDate(happened); + if (timestamp) message += `|d:${timestamp}`; + } + if (options.hostname) message += `|h:${options.hostname}`; + if (options.aggregation_key) message += `|k:${options.aggregation_key}`; + if (options.priority) message += `|p:${options.priority}`; + if (options.source_type_name) message += `|s:${options.source_type_name}`; + if (options.alert_type) message += `|t:${options.alert_type}`; + } + let cb = callback; + let tagList: Tags | undefined = undefined; + if (typeof tags === "function") { + if (callback === undefined) cb = tags; + } else { + tagList = tags; + } + this.send(message, tagList, cb); + } + + // ── sending ── + + private sendAll( + stat: string | string[], + value: number | string, + type: string, + sampleRateArg: SampleArg, + tagsArg: TagsArg, + callbackArg: StatsCb | undefined, + ): void { + let sampleRate: number | undefined = undefined; + let tags: Tags | undefined = undefined; + let callback: StatsCb | undefined = callbackArg; + if (typeof sampleRateArg === "number") { + sampleRate = sampleRateArg; + if (typeof tagsArg === "function") { + callback = tagsArg; + } else { + tags = tagsArg; + } + } else if (sampleRateArg !== undefined) { + // A non-number sample rate shifts into the tags, and the tags + // argument into the callback. + if (typeof sampleRateArg === "function") { + callback = sampleRateArg; + } else { + tags = sampleRateArg; + callback = typeof tagsArg === "function" ? tagsArg : undefined; + } + } else if (typeof tagsArg === "function") { + callback = tagsArg; + } else { + tags = tagsArg; + } + + if (!Array.isArray(stat)) { + this.sendStat(stat, value, type, sampleRate, tags, callback); + return; + } + let completed = 0; + let calledback = false; + let sentBytes = 0; + const count = stat.length; + const onSend: StatsCb = (error, bytes) => { + completed += 1; + if (calledback) return; + if (error) { + if (callback !== undefined) { + calledback = true; + callback(error); + } else { + const handler = this.errorHandler; + if (handler) { + calledback = true; + handler(error); + } + } + return; + } + if (bytes) sentBytes += bytes as number; + if (completed === count && callback !== undefined) callback(null, sentBytes); + }; + for (const item of stat) this.sendStat(item, value, type, sampleRate, tags, onSend); + } + + private sendStat( + stat: string, + value: number | string, + type: string, + sampleRateArg: number | undefined, + tags: Tags | undefined, + callback: StatsCb | undefined, + ): void { + let message = `${this.prefix + stat + this.suffix}:${value}|${type}`; + const sampleRate = sampleRateArg || this.sampleRate; + if (sampleRate && sampleRate < 1) { + if (Math.random() < sampleRate) { + message += `|@${sampleRate}`; + } else { + if (callback) callback(undefined); + return; + } + } + this.send(message, tags, callback); + } + + private send(message: string, tags: Tags | undefined, callback: StatsCb | undefined): void { + let mergedTags = this.globalTags; + if (tags !== undefined) mergedTags = overrideTags(mergedTags, tags, this.telegraf); + if (mergedTags.length > 0) { + if (this.telegraf) { + const parts = message.split(":"); + message = `${parts[0]!},${mergedTags.join(",").replace(/:/g, "=")}:${parts.slice(1).join(":")}`; + } else { + message += `|${this.tagPrefix}${mergedTags.join(this.tagSeparator)}`; + } + } + this.sendRaw(message, callback); + } + + /** hot-shots' `_send`: the message with its tags. */ + private sendRaw(message: string, callback: StatsCb | undefined): void { + const dnsError = this.dnsError; + if (dnsError) { + if (callback) return callback(dnsError); + const handler = this.errorHandler; + if (handler) return handler(dnsError); + throw dnsError; + } + if (!this.mock) { + if (this.maxBufferSize === 0) { + this.sendMessage(message, callback); + } else { + this.enqueue(message, callback); + } + } else { + const buffer = this.mockBuffer; + if (buffer !== undefined) buffer.push(message); + if (callback) callback(null, 0); + } + } + + private enqueue(message: string, callback: StatsCb | undefined): void { + message += "\n"; + if (this.bufferHolder.buffer.length + message.length > this.maxBufferSize) { + this.flushQueue(callback); + this.bufferHolder.buffer += message; + } else { + this.bufferHolder.buffer += message; + if (callback) callback(null); + } + } + + private flushQueue(callback?: StatsCb): void { + this.sendMessage(this.bufferHolder.buffer, callback); + this.bufferHolder.buffer = ""; + } + + private sendMessage(message: string, callback: StatsCb | undefined): void { + if (message === "") { + if (callback) callback(null); + return; + } + const socketWasMissing = this.transport === null; + if (socketWasMissing && this.protocol === PROTOCOL_UDS) { + this.transport = createTransport(this); + if (this.transport !== null) this.maybeAddUDSErrorHandler(); + } + const socket = this.transport; + if (socketWasMissing || socket === null) { + const error = new Error("Socket not created properly. Check previous errors for details."); + if (callback) return callback(error); + const handler = this.errorHandler; + if (handler) return handler(error); + console.error(String(error)); + return; + } + const handleCallback = (err: Error | null, bytes?: number): void => { + this.messagesInFlight--; + let errFormatted: Error | null = null; + if (err) { + errFormatted = errorWithCode( + `Error sending hot-shots message: ${String(err)}`, + (err as NodeJS.ErrnoException).code, + ); + if (this.protocol === PROTOCOL_UDS && (callback || this.errorHandler)) { + this.udsErrorHandler(err); + } + } + if (callback) { + callback(errFormatted, bytes); + } else if (errFormatted) { + const handler = this.errorHandler; + if (handler) { + handler(errFormatted); + } else { + console.error(String(errFormatted)); + } + } + }; + try { + this.messagesInFlight++; + socket.send(Buffer.from(message), handleCallback); + } catch (err) { + handleCallback(err as Error); + } + } + + private onBufferFlushInterval(): void { + this.flushQueue(); + } + + close(callback?: (error?: Error) => void): void { + const stop = this.stopFlushInterval; + if (stop !== undefined) stop(); + this.flushQueue((err) => { + if (err) { + if (callback) return callback(err); + console.error(err); + return; + } + let intervalAttempts = 0; + const waitForMessages = setInterval(() => { + intervalAttempts++; + if (intervalAttempts > 10) { + console.log("hot-shots could not clear out messages in flight but closing anyways"); + this.messagesInFlight = 0; + } + if (this.messagesInFlight <= 0) { + clearInterval(waitForMessages); + this.closeSocket(callback); + } + }, this.closingFlushInterval); + }); + } + + private closeSocket(callback: ((error?: Error) => void) | undefined): void { + let handledError = false; + const handleErr = (err: unknown): void => { + const errMessage = `Error closing hot-shots socket: ${String(err)}`; + if (handledError) { + console.error(errMessage); + } else { + handledError = true; + if (callback) { + callback(new Error(errMessage)); + } else { + const handler = this.errorHandler; + if (handler) { + handler(new Error(errMessage)); + } else { + console.error(errMessage); + } + } + } + }; + const socket = this.transport; + if (socket === null) { + handleErr(new TypeError("Cannot read properties of null (reading 'removeListener')")); + return; + } + const handler = this.errorHandler; + if (handler) socket.offError(handler); + socket.onError(handleErr); + if (callback) { + socket.onClose(() => { + if (!handledError) callback(undefined); + }); + } + try { + socket.close(); + } catch (err) { + handleErr(err); + } + } + + childClient(options?: ChildClientOptions): StatsD { + const o: ChildClientOptions = options ?? {}; + const childTags = o.globalTags; + return new StatsD( + { + isChild: true, + errorHandler: o.errorHandler || this.errorHandler, + host: this.host, + port: this.port, + tagPrefix: this.tagPrefix, + tagSeparator: this.tagSeparator, + prefix: (o.prefix || "") + this.prefix, + suffix: this.suffix + (o.suffix || ""), + globalize: false, + mock: this.mock, + globalTags: + childTags !== undefined + ? overrideTags(this.globalTags, childTags, this.telegraf) + : this.globalTags, + maxBufferSize: this.maxBufferSize, + bufferFlushInterval: this.bufferFlushInterval, + telegraf: this.telegraf, + protocol: this.protocol === "tcp" ? "tcp" : this.protocol === "uds" ? "uds" : "udp", + closingFlushInterval: this.closingFlushInterval, + }, + new ChildInit(this.transport, this.bufferHolder, this.dnsError), + ); + } +} + export default StatsD; diff --git a/packages/compiler/src/frontend/lowering/lower-dgram.ts b/packages/compiler/src/frontend/lowering/lower-dgram.ts index aa90fc7c74..0e0ddf9757 100644 --- a/packages/compiler/src/frontend/lowering/lower-dgram.ts +++ b/packages/compiler/src/frontend/lowering/lower-dgram.ts @@ -612,8 +612,10 @@ export function lowerDgramMethodCall( const fn: IrLibFn = data.type.kind === "string" ? "dgram.sendStr" : "dgram.sendBytes"; return { kind: "libCall", fn, args: [receiver, data, port, host], type: VOID, loc }; } + // TypeScript reaches the ladder for the completion-callback form + // send(msg, port, address, callback) (the hot-shots package shim). if ( - isJsSourceFile(ts.getSourceFileOfNode(call)) && + (isJsSourceFile(ts.getSourceFileOfNode(call)) || args.length === 4) && args.length <= 6 && !args.some(ts.isSpreadElement) ) { From cab61904fd43bfa9d4736e2c9a72b435fd9b9aef Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Wed, 21 Oct 2026 21:55:38 -0700 Subject: [PATCH 03/23] Send hot-shots uds metrics through a native Unix datagram socket Where unix-dgram is installed beside hot-shots, the shim's entry sends through runtime AF_UNIX datagram calls with the addon's semantics; without it, uds reports the addon missing as hot-shots does. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/shims/hot-shots/client.ts | 1033 +++++++++++++++++ .../compiler/shims/hot-shots/v8-unix-dgram.ts | 8 + packages/compiler/shims/hot-shots/v8.ts | 956 +-------------- .../compiler/src/backend/llvm/lib-datagram.ts | 4 + .../src/frontend/lowering/lower-calls.ts | 43 + .../src/frontend/lowering/lower-namespaces.ts | 8 +- .../compiler/src/frontend/package-shims.ts | 27 +- .../compiler/src/ir/builtin-signatures.ts | 7 + packages/runtime/src/scr_dgram.c | 70 ++ 9 files changed, 1202 insertions(+), 954 deletions(-) create mode 100644 packages/compiler/shims/hot-shots/client.ts create mode 100644 packages/compiler/shims/hot-shots/v8-unix-dgram.ts diff --git a/packages/compiler/shims/hot-shots/client.ts b/packages/compiler/shims/hot-shots/client.ts new file mode 100644 index 0000000000..d0b5c8924d --- /dev/null +++ b/packages/compiler/shims/hot-shots/client.ts @@ -0,0 +1,1033 @@ +// scriptc's built-in implementation of the `hot-shots` package, 8.x API: +// a typed port of hot-shots 8.5's StatsD client with the same datagrams, +// callbacks, error messages and child-client sharing, over node:dgram +// (udp), node:net (tcp) and a native Unix datagram socket (uds). The +// entry modules (v8.ts, v8-unix-dgram.ts) say whether the optional +// unix-dgram addon that hot-shots' uds protocol loads is installed. +import * as dgram from "node:dgram"; +import * as dns from "node:dns"; +import * as net from "node:net"; +import * as os from "node:os"; + +export type Tags = { [key: string]: string } | string[]; + +export interface ClientOptions { + bufferFlushInterval?: number; + bufferHolder?: { buffer: string }; + cacheDns?: boolean; + cacheDnsTtl?: number; + errorHandler?: (err: Error) => void; + globalTags?: Tags; + globalize?: boolean; + host?: string; + isChild?: boolean; + maxBufferSize?: number; + mock?: boolean; + path?: string; + port?: number; + prefix?: string; + protocol?: "tcp" | "udp" | "uds"; + sampleRate?: number; + suffix?: string; + telegraf?: boolean; + useDefaultRoute?: boolean; + tagPrefix?: string; + tagSeparator?: string; + udsGracefulErrorHandling?: boolean; + udsGracefulRestartRateLimit?: number; + closingFlushInterval?: number; +} + +export interface ChildClientOptions { + globalTags?: Tags; + prefix?: string; + suffix?: string; + errorHandler?: (err: Error) => void; +} + +export interface CheckOptions { + /** A Unix timestamp; hot-shots also takes a Date, which this shim's + * option records cannot hold yet. */ + date_happened?: number; + hostname?: string; + message?: string; +} + +export interface DatadogChecks { + OK: 0; + WARNING: 1; + CRITICAL: 2; + UNKNOWN: 3; +} + +export type DatadogChecksValues = 0 | 1 | 2 | 3; + +export interface EventOptions { + aggregation_key?: string; + alert_type?: "info" | "warning" | "success" | "error"; + /** A Unix timestamp; hot-shots also takes a Date, which this shim's + * option records cannot hold yet. */ + date_happened?: number; + hostname?: string; + priority?: "low" | "normal"; + source_type_name?: string; +} + +/** A send's completion: hot-shots passes `null` on success. */ +export type StatsCb = (error: Error | null | undefined, bytes?: any) => void; + +type SampleArg = number | Tags | StatsCb | undefined; +type TagsArg = Tags | StatsCb | undefined; + +const PROTOCOL_TCP = "tcp"; +const PROTOCOL_UDS = "uds"; +const PROTOCOL_UDP = "udp"; +const UDS_DEFAULT_GRACEFUL_RESTART_LIMIT = 1000; +const CACHE_DNS_TTL_DEFAULT = 60000; + +function udsErrorCodes(): number[] { + if (process.platform === "linux") { + return [os.constants.errno.ENOTCONN, os.constants.errno.ECONNREFUSED]; + } + if (process.platform === "darwin") { + return [os.constants.errno.EDESTADDRREQ, os.constants.errno.ECONNRESET]; + } + return []; +} +const UDS_ERROR_CODES = udsErrorCodes(); + +// ── helpers ────────────────────────────────────────────────────────────── + +function sanitizeTags(value: string, telegraf: boolean): string { + const blacklist = telegraf ? /:|\||,/g : /:|\||@|,/g; + return String(value).replace(blacklist, "_"); +} + +function formatTags(tags: Tags, telegraf: boolean): string[] { + if (Array.isArray(tags)) return tags; + const out: string[] = []; + for (const key of Object.keys(tags)) { + out.push(`${sanitizeTags(key, telegraf)}:${sanitizeTags(tags[key]!, telegraf)}`); + } + return out; +} + +function isArrayIndexKey(key: string): boolean { + return /^(0|[1-9]\d*)$/.test(key) && Number(key) < 4294967295; +} + +function overrideTags(parent: string[], child: Tags, telegraf: boolean): string[] { + const childKeys: string[] = []; + const childValues = new Map(); + const toAppend: string[] = []; + for (const tag of formatTags(child, telegraf)) { + const idx = tag.indexOf(":"); + if (idx < 1) { + toAppend.push(tag); + } else { + const key = tag.substring(0, idx); + const value = tag.substring(idx + 1); + let values = childValues.get(key); + if (values === undefined) { + values = []; + childValues.set(key, values); + childKeys.push(key); + } + values.push(value); + } + } + const result = parent.filter((tag) => { + const idx = tag.indexOf(":"); + if (idx < 1) return true; + return !childValues.has(tag.substring(0, idx)); + }); + // hot-shots walks an object's keys: array-index keys ascending first, + // then the rest in insertion order. + const indexKeys = childKeys.filter(isArrayIndexKey).sort((a, b) => Number(a) - Number(b)); + const ordered = indexKeys.concat(childKeys.filter((key) => !isArrayIndexKey(key))); + for (const key of ordered) { + for (const value of childValues.get(key)!) result.push(`${key}:${value}`); + } + return result.concat(toAppend); +} + +function formatDate(date: number): number { + return Math.round(date); +} + +function errorWithCode(message: string, code: string | undefined): Error { + const error: NodeJS.ErrnoException = new Error(message); + error.code = code; + return error; +} + +// ── transports ─────────────────────────────────────────────────────────── + +type SendCallback = (err: Error | null, bytes?: number) => void; + +/** The socket a client sends through (hot-shots' transport interface). */ +interface Transport { + createdAt: number; + send(buf: Buffer, callback: SendCallback): void; + close(): void; + onError(listener: (err: Error) => void): void; + offError(listener: (err: Error) => void): void; + onClose(listener: () => void): void; +} + +/** A socket's 'error' listeners, kept by the transport (the typed + * sockets have no removeListener): one socket listener dispatches to a + * snapshot, and an error nobody listens for throws, as an unhandled + * 'error' event does. */ +class ErrorListeners { + private listeners: ((err: Error) => void)[] = []; + add(listener: (err: Error) => void): void { + this.listeners.push(listener); + } + remove(listener: (err: Error) => void): void { + const index = this.listeners.indexOf(listener); + if (index !== -1) this.listeners.splice(index, 1); + } + emit(err: Error): void { + const snapshot = this.listeners.slice(); + if (snapshot.length === 0) throw err; + for (const listener of snapshot) listener(err); + } +} + +function addEol(buf: Buffer): string { + let msg = buf.toString(); + if (msg.length > 0 && msg[msg.length - 1] !== "\n") msg += "\n"; + return msg; +} + +class UdpTransport implements Transport { + createdAt = 0; + private readonly socket: dgram.Socket; + private readonly errors = new ErrorListeners(); + private resolvedAddress: string | undefined = undefined; + private resolvedAt = 0; + private readonly host: string | undefined; + private readonly port: number; + private readonly cacheDns: boolean; + private readonly cacheDnsTtl: number; + constructor(host: string | undefined, port: number, cacheDns: boolean, cacheDnsTtl: number) { + this.host = host; + this.port = port; + this.cacheDns = cacheDns; + this.cacheDnsTtl = cacheDnsTtl; + this.socket = dgram.createSocket("udp4"); + this.socket.unref(); + this.socket.on("error", (err) => this.errors.emit(err)); + } + send(buf: Buffer, callback: SendCallback): void { + if (!this.cacheDns) { + this.socket.send(buf, this.port, this.host || "127.0.0.1", callback); + return; + } + const now = Date.now(); + const cached = this.resolvedAddress; + if (cached === undefined || now - this.resolvedAt > this.cacheDnsTtl) { + dns.lookup(this.host ?? "localhost", (error, address) => { + if (error) { + callback(error); + return; + } + this.resolvedAddress = address; + this.resolvedAt = now; + this.socket.send(buf, this.port, address, callback); + }); + } else { + this.socket.send(buf, this.port, cached, callback); + } + } + close(): void { + this.socket.close(); + } + onError(listener: (err: Error) => void): void { + this.errors.add(listener); + } + offError(listener: (err: Error) => void): void { + this.errors.remove(listener); + } + onClose(listener: () => void): void { + this.socket.on("close", listener); + } +} + +class TcpTransport implements Transport { + createdAt = 0; + private readonly socket: net.Socket; + private readonly errors = new ErrorListeners(); + constructor(host: string | undefined, port: number) { + this.socket = net.connect(port, host ?? "localhost"); + this.socket.setKeepAlive(true); + this.socket.unref(); + this.socket.on("error", (err) => this.errors.emit(err)); + } + send(buf: Buffer, callback: SendCallback): void { + // The typed socket's write takes the data alone; the completion runs + // on the next tick. + this.socket.write(addEol(buf)); + process.nextTick(() => callback(null)); + } + close(): void { + this.socket.destroy(); + } + onError(listener: (err: Error) => void): void { + this.errors.add(listener); + } + offError(listener: (err: Error) => void): void { + this.errors.remove(listener); + } + onClose(listener: () => void): void { + this.socket.on("close", () => listener()); + } +} + +// The runtime's AF_UNIX datagram calls (the unix-dgram addon's binding): +// results >= 0, or a negative errno; send answers 1 when it would block. +declare function scriptcUnixDgramSocket(): number; +declare function scriptcUnixDgramConnect(fd: number, path: string): number; +declare function scriptcUnixDgramSend(fd: number, data: Buffer): number; +declare function scriptcUnixDgramClose(fd: number): number; + +let unixDgramInstalled = false; + +/** Whether the unix-dgram addon is installed beside hot-shots (set by the + * entry module). */ +export function configureUnixDgram(installed: boolean): void { + unixDgramInstalled = installed; +} + +const UDS_PATH_DEFAULT = "/var/run/datadog/dsd.socket"; + +/** unix-dgram's errnoException: " " (the code is the + * negative errno; this Error's code field holds its decimal string). */ +function errnoException(errorno: number, syscall: string): Error { + const error: NodeJS.ErrnoException = new Error(`${syscall} ${errorno}`); + error.errno = errorno; + error.code = String(errorno); + error.syscall = syscall; + return error; +} + +/** hot-shots' uds transport over unix-dgram: a connected, non-blocking + * AF_UNIX datagram socket. Sends complete synchronously, as the addon's + * do. The addon polls the socket for reads, which holds the event loop + * until close; a ref'd timer stands in for that poll. */ +class UdsTransport implements Transport { + createdAt = 0; + private fd: number; + private readonly errors = new ErrorListeners(); + private readonly closeListeners: (() => void)[] = []; + private readonly stopHold: () => void; + constructor(path: string) { + const fd = scriptcUnixDgramSocket(); + if (fd < 0) throw errnoException(fd, "socket"); + this.fd = fd; + const hold = setInterval(() => {}, 2147483647); + this.stopHold = () => clearInterval(hold); + const err = scriptcUnixDgramConnect(fd, path); + if (err < 0) { + // The addon emits the connect failure as 'error' before anyone + // listens, which throws; hot-shots closes the socket and rethrows. + this.close(); + throw errnoException(err, "connect"); + } + } + send(buf: Buffer, callback: SendCallback): void { + const result = scriptcUnixDgramSend(this.fd, buf); + if (result < 0) { + callback(errnoException(result, "send")); + } else if (result === 1) { + const congestion: NodeJS.ErrnoException = new Error("congestion"); + congestion.code = "1"; + callback(congestion); + } else { + callback(null); + } + } + close(): void { + const result = scriptcUnixDgramClose(this.fd); + if (result < 0) throw errnoException(result, "close"); + this.fd = -1; + this.stopHold(); + for (const listener of this.closeListeners.slice()) listener(); + } + onError(listener: (err: Error) => void): void { + this.errors.add(listener); + } + offError(listener: (err: Error) => void): void { + this.errors.remove(listener); + } + onClose(listener: () => void): void { + this.closeListeners.push(listener); + } +} + +/** hot-shots' createUdsTransport: without the unix-dgram addon the + * protocol reports it missing. */ +function createUdsTransport(path: string | undefined): Transport { + if (!unixDgramInstalled) { + throw new Error( + "The library `unix_dgram`, needed for the uds protocol to work, is not installed. " + + "You need to pick another protocol to use hot-shots. " + + "See the hot-shots README for additional details.", + ); + } + return new UdsTransport(path ? path : UDS_PATH_DEFAULT); +} + +function createTransport(client: StatsD): Transport | null { + let transport: Transport | null = null; + const protocol = client.protocol; + try { + if (protocol === PROTOCOL_TCP) { + transport = new TcpTransport(client.host, client.port); + } else if (protocol === PROTOCOL_UDS) { + transport = createUdsTransport(client.path); + } else if (protocol === PROTOCOL_UDP) { + transport = new UdpTransport(client.host, client.port, client.cacheDns, client.cacheDnsTtl); + } else { + throw new Error(`Unsupported protocol '${protocol}'`); + } + transport.createdAt = Date.now(); + } catch (e) { + const handler = client.errorHandler; + if (handler) { + handler(e as Error); + } else { + console.error(e); + } + } + return transport; +} + +// ── the client ─────────────────────────────────────────────────────────── + +class BufferHolder { + buffer = ""; +} + +/** What a child client inherits from its parent. */ +class ChildInit { + socket: Transport | null; + bufferHolder: BufferHolder; + dnsError: Error | undefined; + constructor(socket: Transport | null, bufferHolder: BufferHolder, dnsError: Error | undefined) { + this.socket = socket; + this.bufferHolder = bufferHolder; + this.dnsError = dnsError; + } +} + +export class StatsD { + protocol: string; + cacheDns: boolean; + cacheDnsTtl: number; + host: string | undefined; + port: number; + path: string | undefined; + prefix: string; + suffix: string; + tagPrefix: string; + tagSeparator: string; + mock: boolean; + globalTags: string[]; + telegraf: boolean; + maxBufferSize: number; + sampleRate: number; + bufferFlushInterval: number; + errorHandler: ((err: Error) => void) | undefined; + udsGracefulErrorHandling: boolean; + udsGracefulRestartRateLimit: number; + isChild: boolean; + closingFlushInterval: number; + mockBuffer: string[] | undefined = undefined; + messagesInFlight = 0; + CHECKS: DatadogChecks = { OK: 0, WARNING: 1, CRITICAL: 2, UNKNOWN: 3 }; + private bufferHolder: BufferHolder; + private transport: Transport | null = null; + private dnsError: Error | undefined = undefined; + private stopFlushInterval: (() => void) | undefined = undefined; + + constructor(options?: ClientOptions, child?: ChildInit) { + const o: ClientOptions = options ?? {}; + const protocol = o.protocol ? o.protocol.toLowerCase() : ""; + this.protocol = protocol ? protocol : PROTOCOL_UDP; + this.cacheDns = o.cacheDns === true; + this.cacheDnsTtl = o.cacheDnsTtl || CACHE_DNS_TTL_DEFAULT; + this.host = o.host || process.env["DD_AGENT_HOST"]; + this.port = o.port || parseInt(process.env["DD_DOGSTATSD_PORT"] ?? "", 10) || 8125; + this.path = o.path; + this.prefix = o.prefix || ""; + this.suffix = o.suffix || ""; + this.tagPrefix = o.tagPrefix || "#"; + this.tagSeparator = o.tagSeparator || ","; + this.mock = o.mock === true; + this.telegraf = o.telegraf || false; + const globalTags = o.globalTags; + this.globalTags = globalTags !== undefined ? formatTags(globalTags, this.telegraf) : []; + const entityId = process.env["DD_ENTITY_ID"]; + if (entityId) { + this.globalTags = this.globalTags.filter( + (item) => item.indexOf("dd.internal.entity_id:") !== 0, + ); + this.globalTags.push("dd.internal.entity_id:".concat(sanitizeTags(entityId, false))); + } + this.maxBufferSize = o.maxBufferSize || 0; + this.sampleRate = o.sampleRate || 1; + this.bufferFlushInterval = o.bufferFlushInterval || 1000; + this.bufferHolder = child !== undefined ? child.bufferHolder : new BufferHolder(); + this.errorHandler = o.errorHandler; + const graceful = o.udsGracefulErrorHandling; + this.udsGracefulErrorHandling = graceful === undefined ? true : graceful; + this.udsGracefulRestartRateLimit = + o.udsGracefulRestartRateLimit || UDS_DEFAULT_GRACEFUL_RESTART_LIMIT; + this.isChild = child !== undefined; + this.closingFlushInterval = o.closingFlushInterval || 50; + if (this.mock) this.mockBuffer = []; + if (child === undefined && this.maxBufferSize > 0) { + const handle = setInterval(() => this.onBufferFlushInterval(), this.bufferFlushInterval); + handle.unref(); + this.stopFlushInterval = () => clearInterval(handle); + } + if (child !== undefined) { + if (child.dnsError) this.dnsError = child.dnsError; + this.transport = child.socket; + } + if (!this.transport) this.transport = createTransport(this); + const handler = o.errorHandler; + const transport = this.transport; + if (transport !== null && child === undefined && handler) transport.onError(handler); + if (transport !== null && o.protocol === PROTOCOL_UDS) this.maybeAddUDSErrorHandler(); + } + + private maybeAddUDSErrorHandler(): void { + if (this.isChild || !this.udsGracefulErrorHandling) return; + const transport = this.transport; + if (transport !== null) transport.onError((err) => this.udsErrorHandler(err)); + } + + private udsErrorHandler(err: Error): void { + const code = Number((err as NodeJS.ErrnoException).code); + if (!UDS_ERROR_CODES.includes(-code)) return; + const socket = this.transport; + if (socket === null) return; + if (!socket.createdAt || Date.now() - socket.createdAt < this.udsGracefulRestartRateLimit) { + return; + } + const handler = this.errorHandler; + if (handler) socket.offError(handler); + const newSocket = createTransport(this); + if (newSocket === null) { + const errorMessage = "Could not replace UDS connection with new socket"; + if (handler) { + handler(new Error(errorMessage)); + } else { + console.error(errorMessage); + } + return; + } + socket.close(); + this.transport = newSocket; + this.maybeAddUDSErrorHandler(); + if (handler) { + newSocket.onError(handler); + } else { + newSocket.onError((error) => console.error(`hot-shots UDS error: ${String(error)}`)); + } + } + + // ── stats functions ── + + timing(stat: string | string[], time: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + timing(stat: string | string[], time: number, tags?: Tags, callback?: StatsCb): void; + timing(stat: string | string[], time: number, callback?: StatsCb): void; + timing(stat: string | string[], time: number, sampleRate?: number, callback?: StatsCb): void; + timing( + stat: string | string[], + time: number, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, time, "ms", sampleRate, tags, callback); + } + + increment(stat: string, tags?: Tags): void; + increment(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + increment(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + increment(stat: string | string[], value: number, callback?: StatsCb): void; + increment(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + increment( + stat: string | string[], + value?: number | Tags, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + // A non-number second argument of a two-argument call is the tags. + let amount = 1; + let tagArg: TagsArg = tags; + if (typeof value === "number") { + amount = value; + } else if (sampleRate === undefined && tags === undefined && callback === undefined) { + tagArg = value; + } + this.sendAll(stat, amount, "c", sampleRate, tagArg, callback); + } + + decrement(stat: string, tags?: Tags): void; + decrement(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + decrement(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + decrement(stat: string | string[], value: number, callback?: StatsCb): void; + decrement(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + decrement( + stat: string | string[], + value?: number | Tags, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + let amount = 1; + let tagArg: TagsArg = tags; + if (typeof value === "number") { + amount = value; + } else if (sampleRate === undefined && tags === undefined && callback === undefined) { + tagArg = value; + } + this.sendAll(stat, -amount, "c", sampleRate, tagArg, callback); + } + + histogram(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + histogram(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + histogram(stat: string | string[], value: number, callback?: StatsCb): void; + histogram(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + histogram( + stat: string | string[], + value: number, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "h", sampleRate, tags, callback); + } + + distribution(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + distribution(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + distribution(stat: string | string[], value: number, callback?: StatsCb): void; + distribution(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + distribution( + stat: string | string[], + value: number, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "d", sampleRate, tags, callback); + } + + gauge(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + gauge(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; + gauge(stat: string | string[], value: number, callback?: StatsCb): void; + gauge(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + gauge( + stat: string | string[], + value: number, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "g", sampleRate, tags, callback); + } + + set(stat: string | string[], value: number | string, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + set(stat: string | string[], value: number | string, tags?: Tags, callback?: StatsCb): void; + set(stat: string | string[], value: number | string, callback?: StatsCb): void; + set(stat: string | string[], value: number | string, sampleRate?: number, callback?: StatsCb): void; + set( + stat: string | string[], + value: number | string, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "s", sampleRate, tags, callback); + } + + unique(stat: string | string[], value: number | string, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + unique(stat: string | string[], value: number | string, tags?: Tags, callback?: StatsCb): void; + unique(stat: string | string[], value: number | string, callback?: StatsCb): void; + unique(stat: string | string[], value: number | string, sampleRate?: number, callback?: StatsCb): void; + unique( + stat: string | string[], + value: number | string, + sampleRate?: SampleArg, + tags?: TagsArg, + callback?: StatsCb, + ): void { + this.sendAll(stat, value, "s", sampleRate, tags, callback); + } + + check( + name: string, + status: DatadogChecksValues, + options?: CheckOptions, + tags?: Tags | StatsCb, + callback?: StatsCb, + ): void { + if (this.telegraf) { + const err = new Error("Not supported by Telegraf / InfluxDB"); + if (callback) return callback(err); + const handler = this.errorHandler; + if (handler) return handler(err); + throw err; + } + const check: string[] = ["_sc", this.prefix + name + this.suffix, String(status)]; + const metadata: CheckOptions = options ?? {}; + const happened = metadata.date_happened; + if (happened) { + const timestamp = formatDate(happened); + if (timestamp) check.push(`d:${timestamp}`); + } + if (metadata.hostname) check.push(`h:${metadata.hostname}`); + let mergedTags = this.globalTags; + if (tags !== undefined && typeof tags !== "function") { + mergedTags = overrideTags(mergedTags, tags, this.telegraf); + } + if (mergedTags.length > 0) check.push(`#${mergedTags.join(",")}`); + if (metadata.message) check.push(`m:${metadata.message}`); + let cb = callback; + if (typeof tags === "function" && callback === undefined) cb = tags; + this.sendRaw(check.join("|"), cb); + } + + event( + title: string, + text?: string, + options?: EventOptions, + tags?: Tags | StatsCb, + callback?: StatsCb, + ): void { + if (this.telegraf) { + const err = new Error("Not supported by Telegraf / InfluxDB"); + if (callback) return callback(err); + const handler = this.errorHandler; + if (handler) return handler(err); + throw err; + } + const msgTitle = String(title ? title : ""); + let msgText = String(text ? text : msgTitle); + msgText = msgText.replace(/\n/g, "\\n"); + let message = `_e{${msgTitle.length},${msgText.length}}:${msgTitle}|${msgText}`; + if (options) { + const happened = options.date_happened; + if (happened) { + const timestamp = formatDate(happened); + if (timestamp) message += `|d:${timestamp}`; + } + if (options.hostname) message += `|h:${options.hostname}`; + if (options.aggregation_key) message += `|k:${options.aggregation_key}`; + if (options.priority) message += `|p:${options.priority}`; + if (options.source_type_name) message += `|s:${options.source_type_name}`; + if (options.alert_type) message += `|t:${options.alert_type}`; + } + let cb = callback; + let tagList: Tags | undefined = undefined; + if (typeof tags === "function") { + if (callback === undefined) cb = tags; + } else { + tagList = tags; + } + this.send(message, tagList, cb); + } + + // ── sending ── + + private sendAll( + stat: string | string[], + value: number | string, + type: string, + sampleRateArg: SampleArg, + tagsArg: TagsArg, + callbackArg: StatsCb | undefined, + ): void { + let sampleRate: number | undefined = undefined; + let tags: Tags | undefined = undefined; + let callback: StatsCb | undefined = callbackArg; + if (typeof sampleRateArg === "number") { + sampleRate = sampleRateArg; + if (typeof tagsArg === "function") { + callback = tagsArg; + } else { + tags = tagsArg; + } + } else if (sampleRateArg !== undefined) { + // A non-number sample rate shifts into the tags, and the tags + // argument into the callback. + if (typeof sampleRateArg === "function") { + callback = sampleRateArg; + } else { + tags = sampleRateArg; + callback = typeof tagsArg === "function" ? tagsArg : undefined; + } + } else if (typeof tagsArg === "function") { + callback = tagsArg; + } else { + tags = tagsArg; + } + + if (!Array.isArray(stat)) { + this.sendStat(stat, value, type, sampleRate, tags, callback); + return; + } + let completed = 0; + let calledback = false; + let sentBytes = 0; + const count = stat.length; + const onSend: StatsCb = (error, bytes) => { + completed += 1; + if (calledback) return; + if (error) { + if (callback !== undefined) { + calledback = true; + callback(error); + } else { + const handler = this.errorHandler; + if (handler) { + calledback = true; + handler(error); + } + } + return; + } + if (bytes) sentBytes += bytes as number; + if (completed === count && callback !== undefined) callback(null, sentBytes); + }; + for (const item of stat) this.sendStat(item, value, type, sampleRate, tags, onSend); + } + + private sendStat( + stat: string, + value: number | string, + type: string, + sampleRateArg: number | undefined, + tags: Tags | undefined, + callback: StatsCb | undefined, + ): void { + let message = `${this.prefix + stat + this.suffix}:${value}|${type}`; + const sampleRate = sampleRateArg || this.sampleRate; + if (sampleRate && sampleRate < 1) { + if (Math.random() < sampleRate) { + message += `|@${sampleRate}`; + } else { + if (callback) callback(undefined); + return; + } + } + this.send(message, tags, callback); + } + + private send(message: string, tags: Tags | undefined, callback: StatsCb | undefined): void { + let mergedTags = this.globalTags; + if (tags !== undefined) mergedTags = overrideTags(mergedTags, tags, this.telegraf); + if (mergedTags.length > 0) { + if (this.telegraf) { + const parts = message.split(":"); + message = `${parts[0]!},${mergedTags.join(",").replace(/:/g, "=")}:${parts.slice(1).join(":")}`; + } else { + message += `|${this.tagPrefix}${mergedTags.join(this.tagSeparator)}`; + } + } + this.sendRaw(message, callback); + } + + /** hot-shots' `_send`: the message with its tags. */ + private sendRaw(message: string, callback: StatsCb | undefined): void { + const dnsError = this.dnsError; + if (dnsError) { + if (callback) return callback(dnsError); + const handler = this.errorHandler; + if (handler) return handler(dnsError); + throw dnsError; + } + if (!this.mock) { + if (this.maxBufferSize === 0) { + this.sendMessage(message, callback); + } else { + this.enqueue(message, callback); + } + } else { + const buffer = this.mockBuffer; + if (buffer !== undefined) buffer.push(message); + if (callback) callback(null, 0); + } + } + + private enqueue(message: string, callback: StatsCb | undefined): void { + message += "\n"; + if (this.bufferHolder.buffer.length + message.length > this.maxBufferSize) { + this.flushQueue(callback); + this.bufferHolder.buffer += message; + } else { + this.bufferHolder.buffer += message; + if (callback) callback(null); + } + } + + private flushQueue(callback?: StatsCb): void { + this.sendMessage(this.bufferHolder.buffer, callback); + this.bufferHolder.buffer = ""; + } + + private sendMessage(message: string, callback: StatsCb | undefined): void { + if (message === "") { + if (callback) callback(null); + return; + } + const socketWasMissing = this.transport === null; + if (socketWasMissing && this.protocol === PROTOCOL_UDS) { + this.transport = createTransport(this); + if (this.transport !== null) this.maybeAddUDSErrorHandler(); + } + const socket = this.transport; + if (socketWasMissing || socket === null) { + const error = new Error("Socket not created properly. Check previous errors for details."); + if (callback) return callback(error); + const handler = this.errorHandler; + if (handler) return handler(error); + console.error(String(error)); + return; + } + const handleCallback = (err: Error | null, bytes?: number): void => { + this.messagesInFlight--; + let errFormatted: Error | null = null; + if (err) { + errFormatted = errorWithCode( + `Error sending hot-shots message: ${String(err)}`, + (err as NodeJS.ErrnoException).code, + ); + if (this.protocol === PROTOCOL_UDS && (callback || this.errorHandler)) { + this.udsErrorHandler(err); + } + } + if (callback) { + callback(errFormatted, bytes); + } else if (errFormatted) { + const handler = this.errorHandler; + if (handler) { + handler(errFormatted); + } else { + console.error(String(errFormatted)); + } + } + }; + try { + this.messagesInFlight++; + socket.send(Buffer.from(message), handleCallback); + } catch (err) { + handleCallback(err as Error); + } + } + + private onBufferFlushInterval(): void { + this.flushQueue(); + } + + close(callback?: (error?: Error) => void): void { + const stop = this.stopFlushInterval; + if (stop !== undefined) stop(); + this.flushQueue((err) => { + if (err) { + if (callback) return callback(err); + console.error(err); + return; + } + let intervalAttempts = 0; + const waitForMessages = setInterval(() => { + intervalAttempts++; + if (intervalAttempts > 10) { + console.log("hot-shots could not clear out messages in flight but closing anyways"); + this.messagesInFlight = 0; + } + if (this.messagesInFlight <= 0) { + clearInterval(waitForMessages); + this.closeSocket(callback); + } + }, this.closingFlushInterval); + }); + } + + private closeSocket(callback: ((error?: Error) => void) | undefined): void { + let handledError = false; + const handleErr = (err: unknown): void => { + const errMessage = `Error closing hot-shots socket: ${String(err)}`; + if (handledError) { + console.error(errMessage); + } else { + handledError = true; + if (callback) { + callback(new Error(errMessage)); + } else { + const handler = this.errorHandler; + if (handler) { + handler(new Error(errMessage)); + } else { + console.error(errMessage); + } + } + } + }; + const socket = this.transport; + if (socket === null) { + handleErr(new TypeError("Cannot read properties of null (reading 'removeListener')")); + return; + } + const handler = this.errorHandler; + if (handler) socket.offError(handler); + socket.onError(handleErr); + if (callback) { + socket.onClose(() => { + if (!handledError) callback(undefined); + }); + } + try { + socket.close(); + } catch (err) { + handleErr(err); + } + } + + childClient(options?: ChildClientOptions): StatsD { + const o: ChildClientOptions = options ?? {}; + const childTags = o.globalTags; + return new StatsD( + { + isChild: true, + errorHandler: o.errorHandler || this.errorHandler, + host: this.host, + port: this.port, + tagPrefix: this.tagPrefix, + tagSeparator: this.tagSeparator, + prefix: (o.prefix || "") + this.prefix, + suffix: this.suffix + (o.suffix || ""), + globalize: false, + mock: this.mock, + globalTags: + childTags !== undefined + ? overrideTags(this.globalTags, childTags, this.telegraf) + : this.globalTags, + maxBufferSize: this.maxBufferSize, + bufferFlushInterval: this.bufferFlushInterval, + telegraf: this.telegraf, + protocol: this.protocol === "tcp" ? "tcp" : this.protocol === "uds" ? "uds" : "udp", + closingFlushInterval: this.closingFlushInterval, + }, + new ChildInit(this.transport, this.bufferHolder, this.dnsError), + ); + } +} + +export default StatsD; diff --git a/packages/compiler/shims/hot-shots/v8-unix-dgram.ts b/packages/compiler/shims/hot-shots/v8-unix-dgram.ts new file mode 100644 index 0000000000..f4bfb180e2 --- /dev/null +++ b/packages/compiler/shims/hot-shots/v8-unix-dgram.ts @@ -0,0 +1,8 @@ +// The hot-shots 8.x shim for installations with the optional unix-dgram +// addon: the uds protocol sends through a native Unix datagram socket. +import { configureUnixDgram } from "./client.ts"; + +configureUnixDgram(true); + +export * from "./client.ts"; +export { default } from "./client.ts"; diff --git a/packages/compiler/shims/hot-shots/v8.ts b/packages/compiler/shims/hot-shots/v8.ts index a8af7a19ed..0d18711706 100644 --- a/packages/compiler/shims/hot-shots/v8.ts +++ b/packages/compiler/shims/hot-shots/v8.ts @@ -1,952 +1,8 @@ -// scriptc's built-in implementation of the `hot-shots` package, 8.x API. -// -// Programs whose installed hot-shots is 8.x compile this module in its -// place (packages/compiler/src/frontend/package-shims.ts). It is a typed -// port of hot-shots 8.5's StatsD client: the same datagrams, callbacks, -// error messages and child-client sharing, over node:dgram (udp) and -// node:net (tcp). The uds protocol needs the optional `unix-dgram` addon; -// this entry serves programs where it is not installed, so uds reports -// hot-shots' "not installed" error exactly as Node does. -import * as dgram from "node:dgram"; -import * as dns from "node:dns"; -import * as net from "node:net"; -import * as os from "node:os"; +// The hot-shots 8.x shim for installations without the optional unix-dgram +// addon: the uds protocol reports it missing, as hot-shots does under Node. +import { configureUnixDgram } from "./client.ts"; -export type Tags = { [key: string]: string } | string[]; +configureUnixDgram(false); -export interface ClientOptions { - bufferFlushInterval?: number; - bufferHolder?: { buffer: string }; - cacheDns?: boolean; - cacheDnsTtl?: number; - errorHandler?: (err: Error) => void; - globalTags?: Tags; - globalize?: boolean; - host?: string; - isChild?: boolean; - maxBufferSize?: number; - mock?: boolean; - path?: string; - port?: number; - prefix?: string; - protocol?: "tcp" | "udp" | "uds"; - sampleRate?: number; - suffix?: string; - telegraf?: boolean; - useDefaultRoute?: boolean; - tagPrefix?: string; - tagSeparator?: string; - udsGracefulErrorHandling?: boolean; - udsGracefulRestartRateLimit?: number; - closingFlushInterval?: number; -} - -export interface ChildClientOptions { - globalTags?: Tags; - prefix?: string; - suffix?: string; - errorHandler?: (err: Error) => void; -} - -export interface CheckOptions { - /** A Unix timestamp; hot-shots also takes a Date, which this shim's - * option records cannot hold yet. */ - date_happened?: number; - hostname?: string; - message?: string; -} - -export interface DatadogChecks { - OK: 0; - WARNING: 1; - CRITICAL: 2; - UNKNOWN: 3; -} - -export type DatadogChecksValues = 0 | 1 | 2 | 3; - -export interface EventOptions { - aggregation_key?: string; - alert_type?: "info" | "warning" | "success" | "error"; - /** A Unix timestamp; hot-shots also takes a Date, which this shim's - * option records cannot hold yet. */ - date_happened?: number; - hostname?: string; - priority?: "low" | "normal"; - source_type_name?: string; -} - -/** A send's completion: hot-shots passes `null` on success. */ -export type StatsCb = (error: Error | null | undefined, bytes?: any) => void; - -type SampleArg = number | Tags | StatsCb | undefined; -type TagsArg = Tags | StatsCb | undefined; - -const PROTOCOL_TCP = "tcp"; -const PROTOCOL_UDS = "uds"; -const PROTOCOL_UDP = "udp"; -const UDS_DEFAULT_GRACEFUL_RESTART_LIMIT = 1000; -const CACHE_DNS_TTL_DEFAULT = 60000; - -function udsErrorCodes(): number[] { - if (process.platform === "linux") { - return [os.constants.errno.ENOTCONN, os.constants.errno.ECONNREFUSED]; - } - if (process.platform === "darwin") { - return [os.constants.errno.EDESTADDRREQ, os.constants.errno.ECONNRESET]; - } - return []; -} -const UDS_ERROR_CODES = udsErrorCodes(); - -// ── helpers ────────────────────────────────────────────────────────────── - -function sanitizeTags(value: string, telegraf: boolean): string { - const blacklist = telegraf ? /:|\||,/g : /:|\||@|,/g; - return String(value).replace(blacklist, "_"); -} - -function formatTags(tags: Tags, telegraf: boolean): string[] { - if (Array.isArray(tags)) return tags; - const out: string[] = []; - for (const key of Object.keys(tags)) { - out.push(`${sanitizeTags(key, telegraf)}:${sanitizeTags(tags[key]!, telegraf)}`); - } - return out; -} - -function isArrayIndexKey(key: string): boolean { - return /^(0|[1-9]\d*)$/.test(key) && Number(key) < 4294967295; -} - -function overrideTags(parent: string[], child: Tags, telegraf: boolean): string[] { - const childKeys: string[] = []; - const childValues = new Map(); - const toAppend: string[] = []; - for (const tag of formatTags(child, telegraf)) { - const idx = tag.indexOf(":"); - if (idx < 1) { - toAppend.push(tag); - } else { - const key = tag.substring(0, idx); - const value = tag.substring(idx + 1); - let values = childValues.get(key); - if (values === undefined) { - values = []; - childValues.set(key, values); - childKeys.push(key); - } - values.push(value); - } - } - const result = parent.filter((tag) => { - const idx = tag.indexOf(":"); - if (idx < 1) return true; - return !childValues.has(tag.substring(0, idx)); - }); - // hot-shots walks an object's keys: array-index keys ascending first, - // then the rest in insertion order. - const indexKeys = childKeys.filter(isArrayIndexKey).sort((a, b) => Number(a) - Number(b)); - const ordered = indexKeys.concat(childKeys.filter((key) => !isArrayIndexKey(key))); - for (const key of ordered) { - for (const value of childValues.get(key)!) result.push(`${key}:${value}`); - } - return result.concat(toAppend); -} - -function formatDate(date: number): number { - return Math.round(date); -} - -function errorWithCode(message: string, code: string | undefined): Error { - const error: NodeJS.ErrnoException = new Error(message); - error.code = code; - return error; -} - -// ── transports ─────────────────────────────────────────────────────────── - -type SendCallback = (err: Error | null, bytes?: number) => void; - -/** The socket a client sends through (hot-shots' transport interface). */ -interface Transport { - createdAt: number; - send(buf: Buffer, callback: SendCallback): void; - close(): void; - onError(listener: (err: Error) => void): void; - offError(listener: (err: Error) => void): void; - onClose(listener: () => void): void; -} - -/** A socket's 'error' listeners, kept by the transport (the typed - * sockets have no removeListener): one socket listener dispatches to a - * snapshot, and an error nobody listens for throws, as an unhandled - * 'error' event does. */ -class ErrorListeners { - private listeners: ((err: Error) => void)[] = []; - add(listener: (err: Error) => void): void { - this.listeners.push(listener); - } - remove(listener: (err: Error) => void): void { - const index = this.listeners.indexOf(listener); - if (index !== -1) this.listeners.splice(index, 1); - } - emit(err: Error): void { - const snapshot = this.listeners.slice(); - if (snapshot.length === 0) throw err; - for (const listener of snapshot) listener(err); - } -} - -function addEol(buf: Buffer): string { - let msg = buf.toString(); - if (msg.length > 0 && msg[msg.length - 1] !== "\n") msg += "\n"; - return msg; -} - -class UdpTransport implements Transport { - createdAt = 0; - private readonly socket: dgram.Socket; - private readonly errors = new ErrorListeners(); - private resolvedAddress: string | undefined = undefined; - private resolvedAt = 0; - private readonly host: string | undefined; - private readonly port: number; - private readonly cacheDns: boolean; - private readonly cacheDnsTtl: number; - constructor(host: string | undefined, port: number, cacheDns: boolean, cacheDnsTtl: number) { - this.host = host; - this.port = port; - this.cacheDns = cacheDns; - this.cacheDnsTtl = cacheDnsTtl; - this.socket = dgram.createSocket("udp4"); - this.socket.unref(); - this.socket.on("error", (err) => this.errors.emit(err)); - } - send(buf: Buffer, callback: SendCallback): void { - if (!this.cacheDns) { - this.socket.send(buf, this.port, this.host || "127.0.0.1", callback); - return; - } - const now = Date.now(); - const cached = this.resolvedAddress; - if (cached === undefined || now - this.resolvedAt > this.cacheDnsTtl) { - dns.lookup(this.host ?? "localhost", (error, address) => { - if (error) { - callback(error); - return; - } - this.resolvedAddress = address; - this.resolvedAt = now; - this.socket.send(buf, this.port, address, callback); - }); - } else { - this.socket.send(buf, this.port, cached, callback); - } - } - close(): void { - this.socket.close(); - } - onError(listener: (err: Error) => void): void { - this.errors.add(listener); - } - offError(listener: (err: Error) => void): void { - this.errors.remove(listener); - } - onClose(listener: () => void): void { - this.socket.on("close", listener); - } -} - -class TcpTransport implements Transport { - createdAt = 0; - private readonly socket: net.Socket; - private readonly errors = new ErrorListeners(); - constructor(host: string | undefined, port: number) { - this.socket = net.connect(port, host ?? "localhost"); - this.socket.setKeepAlive(true); - this.socket.unref(); - this.socket.on("error", (err) => this.errors.emit(err)); - } - send(buf: Buffer, callback: SendCallback): void { - // The typed socket's write takes the data alone; the completion runs - // on the next tick. - this.socket.write(addEol(buf)); - process.nextTick(() => callback(null)); - } - close(): void { - this.socket.destroy(); - } - onError(listener: (err: Error) => void): void { - this.errors.add(listener); - } - offError(listener: (err: Error) => void): void { - this.errors.remove(listener); - } - onClose(listener: () => void): void { - this.socket.on("close", () => listener()); - } -} - -/** hot-shots reaches Unix datagram sockets through the optional - * `unix-dgram` addon; this entry serves programs without it. */ -function createUdsTransport(): Transport { - throw new Error( - "The library `unix_dgram`, needed for the uds protocol to work, is not installed. " + - "You need to pick another protocol to use hot-shots. " + - "See the hot-shots README for additional details.", - ); -} - -function createTransport(client: StatsD): Transport | null { - let transport: Transport | null = null; - const protocol = client.protocol; - try { - if (protocol === PROTOCOL_TCP) { - transport = new TcpTransport(client.host, client.port); - } else if (protocol === PROTOCOL_UDS) { - transport = createUdsTransport(); - } else if (protocol === PROTOCOL_UDP) { - transport = new UdpTransport(client.host, client.port, client.cacheDns, client.cacheDnsTtl); - } else { - throw new Error(`Unsupported protocol '${protocol}'`); - } - transport.createdAt = Date.now(); - } catch (e) { - const handler = client.errorHandler; - if (handler) { - handler(e as Error); - } else { - console.error(e); - } - } - return transport; -} - -// ── the client ─────────────────────────────────────────────────────────── - -class BufferHolder { - buffer = ""; -} - -/** What a child client inherits from its parent. */ -class ChildInit { - socket: Transport | null; - bufferHolder: BufferHolder; - dnsError: Error | undefined; - constructor(socket: Transport | null, bufferHolder: BufferHolder, dnsError: Error | undefined) { - this.socket = socket; - this.bufferHolder = bufferHolder; - this.dnsError = dnsError; - } -} - -export class StatsD { - protocol: string; - cacheDns: boolean; - cacheDnsTtl: number; - host: string | undefined; - port: number; - path: string | undefined; - prefix: string; - suffix: string; - tagPrefix: string; - tagSeparator: string; - mock: boolean; - globalTags: string[]; - telegraf: boolean; - maxBufferSize: number; - sampleRate: number; - bufferFlushInterval: number; - errorHandler: ((err: Error) => void) | undefined; - udsGracefulErrorHandling: boolean; - udsGracefulRestartRateLimit: number; - isChild: boolean; - closingFlushInterval: number; - mockBuffer: string[] | undefined = undefined; - messagesInFlight = 0; - CHECKS: DatadogChecks = { OK: 0, WARNING: 1, CRITICAL: 2, UNKNOWN: 3 }; - private bufferHolder: BufferHolder; - private transport: Transport | null = null; - private dnsError: Error | undefined = undefined; - private stopFlushInterval: (() => void) | undefined = undefined; - - constructor(options?: ClientOptions, child?: ChildInit) { - const o: ClientOptions = options ?? {}; - const protocol = o.protocol ? o.protocol.toLowerCase() : ""; - this.protocol = protocol ? protocol : PROTOCOL_UDP; - this.cacheDns = o.cacheDns === true; - this.cacheDnsTtl = o.cacheDnsTtl || CACHE_DNS_TTL_DEFAULT; - this.host = o.host || process.env["DD_AGENT_HOST"]; - this.port = o.port || parseInt(process.env["DD_DOGSTATSD_PORT"] ?? "", 10) || 8125; - this.path = o.path; - this.prefix = o.prefix || ""; - this.suffix = o.suffix || ""; - this.tagPrefix = o.tagPrefix || "#"; - this.tagSeparator = o.tagSeparator || ","; - this.mock = o.mock === true; - this.telegraf = o.telegraf || false; - const globalTags = o.globalTags; - this.globalTags = globalTags !== undefined ? formatTags(globalTags, this.telegraf) : []; - const entityId = process.env["DD_ENTITY_ID"]; - if (entityId) { - this.globalTags = this.globalTags.filter( - (item) => item.indexOf("dd.internal.entity_id:") !== 0, - ); - this.globalTags.push("dd.internal.entity_id:".concat(sanitizeTags(entityId, false))); - } - this.maxBufferSize = o.maxBufferSize || 0; - this.sampleRate = o.sampleRate || 1; - this.bufferFlushInterval = o.bufferFlushInterval || 1000; - this.bufferHolder = child !== undefined ? child.bufferHolder : new BufferHolder(); - this.errorHandler = o.errorHandler; - const graceful = o.udsGracefulErrorHandling; - this.udsGracefulErrorHandling = graceful === undefined ? true : graceful; - this.udsGracefulRestartRateLimit = - o.udsGracefulRestartRateLimit || UDS_DEFAULT_GRACEFUL_RESTART_LIMIT; - this.isChild = child !== undefined; - this.closingFlushInterval = o.closingFlushInterval || 50; - if (this.mock) this.mockBuffer = []; - if (child === undefined && this.maxBufferSize > 0) { - const handle = setInterval(() => this.onBufferFlushInterval(), this.bufferFlushInterval); - handle.unref(); - this.stopFlushInterval = () => clearInterval(handle); - } - if (child !== undefined) { - if (child.dnsError) this.dnsError = child.dnsError; - this.transport = child.socket; - } - if (!this.transport) this.transport = createTransport(this); - const handler = o.errorHandler; - const transport = this.transport; - if (transport !== null && child === undefined && handler) transport.onError(handler); - if (transport !== null && o.protocol === PROTOCOL_UDS) this.maybeAddUDSErrorHandler(); - } - - private maybeAddUDSErrorHandler(): void { - if (this.isChild || !this.udsGracefulErrorHandling) return; - const transport = this.transport; - if (transport !== null) transport.onError((err) => this.udsErrorHandler(err)); - } - - private udsErrorHandler(err: Error): void { - const code = Number((err as NodeJS.ErrnoException).code); - if (!UDS_ERROR_CODES.includes(-code)) return; - const socket = this.transport; - if (socket === null) return; - if (!socket.createdAt || Date.now() - socket.createdAt < this.udsGracefulRestartRateLimit) { - return; - } - const handler = this.errorHandler; - if (handler) socket.offError(handler); - const newSocket = createTransport(this); - if (newSocket === null) { - const errorMessage = "Could not replace UDS connection with new socket"; - if (handler) { - handler(new Error(errorMessage)); - } else { - console.error(errorMessage); - } - return; - } - socket.close(); - this.transport = newSocket; - this.maybeAddUDSErrorHandler(); - if (handler) { - newSocket.onError(handler); - } else { - newSocket.onError((error) => console.error(`hot-shots UDS error: ${String(error)}`)); - } - } - - // ── stats functions ── - - timing(stat: string | string[], time: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; - timing(stat: string | string[], time: number, tags?: Tags, callback?: StatsCb): void; - timing(stat: string | string[], time: number, callback?: StatsCb): void; - timing(stat: string | string[], time: number, sampleRate?: number, callback?: StatsCb): void; - timing( - stat: string | string[], - time: number, - sampleRate?: SampleArg, - tags?: TagsArg, - callback?: StatsCb, - ): void { - this.sendAll(stat, time, "ms", sampleRate, tags, callback); - } - - increment(stat: string, tags?: Tags): void; - increment(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; - increment(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; - increment(stat: string | string[], value: number, callback?: StatsCb): void; - increment(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; - increment( - stat: string | string[], - value?: number | Tags, - sampleRate?: SampleArg, - tags?: TagsArg, - callback?: StatsCb, - ): void { - // A non-number second argument of a two-argument call is the tags. - let amount = 1; - let tagArg: TagsArg = tags; - if (typeof value === "number") { - amount = value; - } else if (sampleRate === undefined && tags === undefined && callback === undefined) { - tagArg = value; - } - this.sendAll(stat, amount, "c", sampleRate, tagArg, callback); - } - - decrement(stat: string, tags?: Tags): void; - decrement(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; - decrement(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; - decrement(stat: string | string[], value: number, callback?: StatsCb): void; - decrement(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; - decrement( - stat: string | string[], - value?: number | Tags, - sampleRate?: SampleArg, - tags?: TagsArg, - callback?: StatsCb, - ): void { - let amount = 1; - let tagArg: TagsArg = tags; - if (typeof value === "number") { - amount = value; - } else if (sampleRate === undefined && tags === undefined && callback === undefined) { - tagArg = value; - } - this.sendAll(stat, -amount, "c", sampleRate, tagArg, callback); - } - - histogram(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; - histogram(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; - histogram(stat: string | string[], value: number, callback?: StatsCb): void; - histogram(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; - histogram( - stat: string | string[], - value: number, - sampleRate?: SampleArg, - tags?: TagsArg, - callback?: StatsCb, - ): void { - this.sendAll(stat, value, "h", sampleRate, tags, callback); - } - - distribution(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; - distribution(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; - distribution(stat: string | string[], value: number, callback?: StatsCb): void; - distribution(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; - distribution( - stat: string | string[], - value: number, - sampleRate?: SampleArg, - tags?: TagsArg, - callback?: StatsCb, - ): void { - this.sendAll(stat, value, "d", sampleRate, tags, callback); - } - - gauge(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; - gauge(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; - gauge(stat: string | string[], value: number, callback?: StatsCb): void; - gauge(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; - gauge( - stat: string | string[], - value: number, - sampleRate?: SampleArg, - tags?: TagsArg, - callback?: StatsCb, - ): void { - this.sendAll(stat, value, "g", sampleRate, tags, callback); - } - - set(stat: string | string[], value: number | string, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; - set(stat: string | string[], value: number | string, tags?: Tags, callback?: StatsCb): void; - set(stat: string | string[], value: number | string, callback?: StatsCb): void; - set(stat: string | string[], value: number | string, sampleRate?: number, callback?: StatsCb): void; - set( - stat: string | string[], - value: number | string, - sampleRate?: SampleArg, - tags?: TagsArg, - callback?: StatsCb, - ): void { - this.sendAll(stat, value, "s", sampleRate, tags, callback); - } - - unique(stat: string | string[], value: number | string, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; - unique(stat: string | string[], value: number | string, tags?: Tags, callback?: StatsCb): void; - unique(stat: string | string[], value: number | string, callback?: StatsCb): void; - unique(stat: string | string[], value: number | string, sampleRate?: number, callback?: StatsCb): void; - unique( - stat: string | string[], - value: number | string, - sampleRate?: SampleArg, - tags?: TagsArg, - callback?: StatsCb, - ): void { - this.sendAll(stat, value, "s", sampleRate, tags, callback); - } - - check( - name: string, - status: DatadogChecksValues, - options?: CheckOptions, - tags?: Tags | StatsCb, - callback?: StatsCb, - ): void { - if (this.telegraf) { - const err = new Error("Not supported by Telegraf / InfluxDB"); - if (callback) return callback(err); - const handler = this.errorHandler; - if (handler) return handler(err); - throw err; - } - const check: string[] = ["_sc", this.prefix + name + this.suffix, String(status)]; - const metadata: CheckOptions = options ?? {}; - const happened = metadata.date_happened; - if (happened) { - const timestamp = formatDate(happened); - if (timestamp) check.push(`d:${timestamp}`); - } - if (metadata.hostname) check.push(`h:${metadata.hostname}`); - let mergedTags = this.globalTags; - if (tags !== undefined && typeof tags !== "function") { - mergedTags = overrideTags(mergedTags, tags, this.telegraf); - } - if (mergedTags.length > 0) check.push(`#${mergedTags.join(",")}`); - if (metadata.message) check.push(`m:${metadata.message}`); - let cb = callback; - if (typeof tags === "function" && callback === undefined) cb = tags; - this.sendRaw(check.join("|"), cb); - } - - event( - title: string, - text?: string, - options?: EventOptions, - tags?: Tags | StatsCb, - callback?: StatsCb, - ): void { - if (this.telegraf) { - const err = new Error("Not supported by Telegraf / InfluxDB"); - if (callback) return callback(err); - const handler = this.errorHandler; - if (handler) return handler(err); - throw err; - } - const msgTitle = String(title ? title : ""); - let msgText = String(text ? text : msgTitle); - msgText = msgText.replace(/\n/g, "\\n"); - let message = `_e{${msgTitle.length},${msgText.length}}:${msgTitle}|${msgText}`; - if (options) { - const happened = options.date_happened; - if (happened) { - const timestamp = formatDate(happened); - if (timestamp) message += `|d:${timestamp}`; - } - if (options.hostname) message += `|h:${options.hostname}`; - if (options.aggregation_key) message += `|k:${options.aggregation_key}`; - if (options.priority) message += `|p:${options.priority}`; - if (options.source_type_name) message += `|s:${options.source_type_name}`; - if (options.alert_type) message += `|t:${options.alert_type}`; - } - let cb = callback; - let tagList: Tags | undefined = undefined; - if (typeof tags === "function") { - if (callback === undefined) cb = tags; - } else { - tagList = tags; - } - this.send(message, tagList, cb); - } - - // ── sending ── - - private sendAll( - stat: string | string[], - value: number | string, - type: string, - sampleRateArg: SampleArg, - tagsArg: TagsArg, - callbackArg: StatsCb | undefined, - ): void { - let sampleRate: number | undefined = undefined; - let tags: Tags | undefined = undefined; - let callback: StatsCb | undefined = callbackArg; - if (typeof sampleRateArg === "number") { - sampleRate = sampleRateArg; - if (typeof tagsArg === "function") { - callback = tagsArg; - } else { - tags = tagsArg; - } - } else if (sampleRateArg !== undefined) { - // A non-number sample rate shifts into the tags, and the tags - // argument into the callback. - if (typeof sampleRateArg === "function") { - callback = sampleRateArg; - } else { - tags = sampleRateArg; - callback = typeof tagsArg === "function" ? tagsArg : undefined; - } - } else if (typeof tagsArg === "function") { - callback = tagsArg; - } else { - tags = tagsArg; - } - - if (!Array.isArray(stat)) { - this.sendStat(stat, value, type, sampleRate, tags, callback); - return; - } - let completed = 0; - let calledback = false; - let sentBytes = 0; - const count = stat.length; - const onSend: StatsCb = (error, bytes) => { - completed += 1; - if (calledback) return; - if (error) { - if (callback !== undefined) { - calledback = true; - callback(error); - } else { - const handler = this.errorHandler; - if (handler) { - calledback = true; - handler(error); - } - } - return; - } - if (bytes) sentBytes += bytes as number; - if (completed === count && callback !== undefined) callback(null, sentBytes); - }; - for (const item of stat) this.sendStat(item, value, type, sampleRate, tags, onSend); - } - - private sendStat( - stat: string, - value: number | string, - type: string, - sampleRateArg: number | undefined, - tags: Tags | undefined, - callback: StatsCb | undefined, - ): void { - let message = `${this.prefix + stat + this.suffix}:${value}|${type}`; - const sampleRate = sampleRateArg || this.sampleRate; - if (sampleRate && sampleRate < 1) { - if (Math.random() < sampleRate) { - message += `|@${sampleRate}`; - } else { - if (callback) callback(undefined); - return; - } - } - this.send(message, tags, callback); - } - - private send(message: string, tags: Tags | undefined, callback: StatsCb | undefined): void { - let mergedTags = this.globalTags; - if (tags !== undefined) mergedTags = overrideTags(mergedTags, tags, this.telegraf); - if (mergedTags.length > 0) { - if (this.telegraf) { - const parts = message.split(":"); - message = `${parts[0]!},${mergedTags.join(",").replace(/:/g, "=")}:${parts.slice(1).join(":")}`; - } else { - message += `|${this.tagPrefix}${mergedTags.join(this.tagSeparator)}`; - } - } - this.sendRaw(message, callback); - } - - /** hot-shots' `_send`: the message with its tags. */ - private sendRaw(message: string, callback: StatsCb | undefined): void { - const dnsError = this.dnsError; - if (dnsError) { - if (callback) return callback(dnsError); - const handler = this.errorHandler; - if (handler) return handler(dnsError); - throw dnsError; - } - if (!this.mock) { - if (this.maxBufferSize === 0) { - this.sendMessage(message, callback); - } else { - this.enqueue(message, callback); - } - } else { - const buffer = this.mockBuffer; - if (buffer !== undefined) buffer.push(message); - if (callback) callback(null, 0); - } - } - - private enqueue(message: string, callback: StatsCb | undefined): void { - message += "\n"; - if (this.bufferHolder.buffer.length + message.length > this.maxBufferSize) { - this.flushQueue(callback); - this.bufferHolder.buffer += message; - } else { - this.bufferHolder.buffer += message; - if (callback) callback(null); - } - } - - private flushQueue(callback?: StatsCb): void { - this.sendMessage(this.bufferHolder.buffer, callback); - this.bufferHolder.buffer = ""; - } - - private sendMessage(message: string, callback: StatsCb | undefined): void { - if (message === "") { - if (callback) callback(null); - return; - } - const socketWasMissing = this.transport === null; - if (socketWasMissing && this.protocol === PROTOCOL_UDS) { - this.transport = createTransport(this); - if (this.transport !== null) this.maybeAddUDSErrorHandler(); - } - const socket = this.transport; - if (socketWasMissing || socket === null) { - const error = new Error("Socket not created properly. Check previous errors for details."); - if (callback) return callback(error); - const handler = this.errorHandler; - if (handler) return handler(error); - console.error(String(error)); - return; - } - const handleCallback = (err: Error | null, bytes?: number): void => { - this.messagesInFlight--; - let errFormatted: Error | null = null; - if (err) { - errFormatted = errorWithCode( - `Error sending hot-shots message: ${String(err)}`, - (err as NodeJS.ErrnoException).code, - ); - if (this.protocol === PROTOCOL_UDS && (callback || this.errorHandler)) { - this.udsErrorHandler(err); - } - } - if (callback) { - callback(errFormatted, bytes); - } else if (errFormatted) { - const handler = this.errorHandler; - if (handler) { - handler(errFormatted); - } else { - console.error(String(errFormatted)); - } - } - }; - try { - this.messagesInFlight++; - socket.send(Buffer.from(message), handleCallback); - } catch (err) { - handleCallback(err as Error); - } - } - - private onBufferFlushInterval(): void { - this.flushQueue(); - } - - close(callback?: (error?: Error) => void): void { - const stop = this.stopFlushInterval; - if (stop !== undefined) stop(); - this.flushQueue((err) => { - if (err) { - if (callback) return callback(err); - console.error(err); - return; - } - let intervalAttempts = 0; - const waitForMessages = setInterval(() => { - intervalAttempts++; - if (intervalAttempts > 10) { - console.log("hot-shots could not clear out messages in flight but closing anyways"); - this.messagesInFlight = 0; - } - if (this.messagesInFlight <= 0) { - clearInterval(waitForMessages); - this.closeSocket(callback); - } - }, this.closingFlushInterval); - }); - } - - private closeSocket(callback: ((error?: Error) => void) | undefined): void { - let handledError = false; - const handleErr = (err: unknown): void => { - const errMessage = `Error closing hot-shots socket: ${String(err)}`; - if (handledError) { - console.error(errMessage); - } else { - handledError = true; - if (callback) { - callback(new Error(errMessage)); - } else { - const handler = this.errorHandler; - if (handler) { - handler(new Error(errMessage)); - } else { - console.error(errMessage); - } - } - } - }; - const socket = this.transport; - if (socket === null) { - handleErr(new TypeError("Cannot read properties of null (reading 'removeListener')")); - return; - } - const handler = this.errorHandler; - if (handler) socket.offError(handler); - socket.onError(handleErr); - if (callback) { - socket.onClose(() => { - if (!handledError) callback(undefined); - }); - } - try { - socket.close(); - } catch (err) { - handleErr(err); - } - } - - childClient(options?: ChildClientOptions): StatsD { - const o: ChildClientOptions = options ?? {}; - const childTags = o.globalTags; - return new StatsD( - { - isChild: true, - errorHandler: o.errorHandler || this.errorHandler, - host: this.host, - port: this.port, - tagPrefix: this.tagPrefix, - tagSeparator: this.tagSeparator, - prefix: (o.prefix || "") + this.prefix, - suffix: this.suffix + (o.suffix || ""), - globalize: false, - mock: this.mock, - globalTags: - childTags !== undefined - ? overrideTags(this.globalTags, childTags, this.telegraf) - : this.globalTags, - maxBufferSize: this.maxBufferSize, - bufferFlushInterval: this.bufferFlushInterval, - telegraf: this.telegraf, - protocol: this.protocol === "tcp" ? "tcp" : this.protocol === "uds" ? "uds" : "udp", - closingFlushInterval: this.closingFlushInterval, - }, - new ChildInit(this.transport, this.bufferHolder, this.dnsError), - ); - } -} - -export default StatsD; +export * from "./client.ts"; +export { default } from "./client.ts"; diff --git a/packages/compiler/src/backend/llvm/lib-datagram.ts b/packages/compiler/src/backend/llvm/lib-datagram.ts index 184fdb99e9..6e10e9c626 100644 --- a/packages/compiler/src/backend/llvm/lib-datagram.ts +++ b/packages/compiler/src/backend/llvm/lib-datagram.ts @@ -105,6 +105,10 @@ export function emitDatagramLibCall(host: LlvmEmitterContext, e: LibCallExpr): L "dgram.sendStr": "scr_dgram_send_str", "dgram.sendBytes": "scr_dgram_send_bytes", "dgram.sendChk": "scr_dgram_send_chk", + "dgram.unixSocket": "scr_dgram_unix_socket", + "dgram.unixConnect": "scr_dgram_unix_connect", + "dgram.unixSend": "scr_dgram_unix_send", + "dgram.unixClose": "scr_dgram_unix_close", "dgram.ref": "scr_dgram_ref", "dgram.unref": "scr_dgram_unref", "dgram.setBroadcast": "scr_dgram_set_broadcast", diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 53971c7b02..3c04924c0b 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -45,6 +45,7 @@ import { errorToStringCall } from "./error-methods.js"; import { lowerClassPrototypeAssign, lowerClassPrototypeDescriptors } from "./class-prototypes.js"; import { BYTES_ELEMENT_NAME, + BYTES_U8, BIGINT_T, BOOL, CAUGHT, @@ -53,6 +54,7 @@ import { F64, type IrExpr, type IrFunction, + type IrLibFn, type IrLocal, type IrParam, type IrStmt, @@ -76,6 +78,7 @@ import { } from "../../ir/ir.js"; import { lowerProtocolMethodCall } from "./class-protocol-dispatch.js"; import { isJsSourceFile, locOf, requireSpecOf } from "../program.js"; +import { isPackageShimFile, isShimIntrinsicName } from "../package-shims.js"; import { lowerJsonRequireCall } from "./json-require.js"; import { lowerAssertInstanceCall } from "./assert-instances.js"; import { @@ -292,6 +295,12 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr { const codeGeneration = codeGenerationCalleeOf(lowerer, expr.expression); if (codeGeneration !== null) return lowerCodeGenerationCall(lowerer, expr, codeGeneration); } + // A package shim's runtime intrinsic (a bodiless `declare function` + // named scriptcUnixDgram* in a shipped shim): a direct runtime call. + if (ts.isIdentifier(expr.expression) && isShimIntrinsicName(expr.expression.text)) { + const intrinsic = lowerShimIntrinsicCall(lowerer, expr, expr.expression, loc); + if (intrinsic) return intrinsic; + } // Inline require() of a program module (cjs-inline-require.ts): a // member call over its export table resolves like a binding's member // call after the module's %init at this position; the require itself @@ -10958,3 +10967,37 @@ function fenceClassCopyIntoFreshObject( `Object.assign copying a '${lowerer.fmt(rawSource.type)}' instance into a fresh object typed as the class (the copy is a plain object holding the instance's own fields, not an instance — build the object literal from the fields you need)`, ); } + +/** The runtime calls package shims declare as bodiless functions. */ +const SHIM_INTRINSICS: ReadonlyMap = new Map< + string, + { fn: IrLibFn; args: IrType[]; ret: IrType } +>([ + ["scriptcUnixDgramSocket", { fn: "dgram.unixSocket", args: [], ret: F64 }], + ["scriptcUnixDgramConnect", { fn: "dgram.unixConnect", args: [F64, STRING], ret: F64 }], + ["scriptcUnixDgramSend", { fn: "dgram.unixSend", args: [F64, BYTES_U8], ret: F64 }], + ["scriptcUnixDgramClose", { fn: "dgram.unixClose", args: [F64], ret: F64 }], +]); + +function lowerShimIntrinsicCall( + lowerer: Lowerer, + expr: ts.CallExpression, + callee: ts.Identifier, + loc: SrcLoc, +): IrExpr | null { + const intrinsic = SHIM_INTRINSICS.get(callee.text); + if (intrinsic === undefined) return null; + const decl = lowerer.checker.getSymbolAtLocation(callee)?.valueDeclaration; + if ( + decl === undefined || + !ts.isFunctionDeclaration(decl) || + decl.body || + !isPackageShimFile(ts.getSourceFileOfNode(decl).fileName) || + expr.arguments.nodes.length !== intrinsic.args.length + ) + return null; + const args = expr.arguments.nodes.map((arg, i) => + lowerer.lowerExprExpecting(arg, intrinsic.args[i]!), + ); + return { kind: "libCall", fn: intrinsic.fn, args, type: intrinsic.ret, loc }; +} diff --git a/packages/compiler/src/frontend/lowering/lower-namespaces.ts b/packages/compiler/src/frontend/lowering/lower-namespaces.ts index 19123dae3d..ea844ab1ea 100644 --- a/packages/compiler/src/frontend/lowering/lower-namespaces.ts +++ b/packages/compiler/src/frontend/lowering/lower-namespaces.ts @@ -38,7 +38,7 @@ * calls). */ import { positionTag, type PositionTagOwner } from "./structural-positions.js"; import * as ts from "../ts7/adapter.js"; -import { packageShimFor } from "../package-shims.js"; +import { isPackageShimFile, isShimIntrinsicName, packageShimFor } from "../package-shims.js"; import type { Lowerer } from "./lowerer.js"; import { boundIdentifiersOf } from "./lowerer.js"; import type { FileParts } from "./lower-modules.js"; @@ -654,6 +654,12 @@ export function ambientUndefinedFnSymbolOf( const sym = lowerer.resolveValueSymbol(ident); if (!sym || !(sym.flags & ts.SymbolFlags.Function)) return null; if (lowerer.isStdlibSymbol(sym)) return null; + // A package shim's runtime intrinsic (lower-calls.ts) is defined. + if ( + isShimIntrinsicName(ident.text) && + sym.declarations.some((d) => isPackageShimFile(ts.getSourceFileOfNode(d).fileName)) + ) + return null; let sawFn = false; for (const d of sym.declarations) { if (ts.isInterfaceDeclaration(d) || ts.isTypeAliasDeclaration(d)) continue; // type-world merge partners diff --git a/packages/compiler/src/frontend/package-shims.ts b/packages/compiler/src/frontend/package-shims.ts index f9cf1deb67..3af7ebf594 100644 --- a/packages/compiler/src/frontend/package-shims.ts +++ b/packages/compiler/src/frontend/package-shims.ts @@ -65,9 +65,14 @@ interface ImplementationShim { /** The package's declaration entry relative to its directory, when it * is not `index.d.ts`. */ typesFile?: string; + /** An alternative entry for this installation (relative to the shim + * root), or undefined for the version's own entry. */ + variant?: (pkgDir: string) => string | undefined; + /** Every variant entry, for the guard test that compiles each one. */ + variants?: readonly string[]; } -const IMPLEMENTATION_SHIMS: ReadonlyMap = new Map([ +const IMPLEMENTATION_SHIMS: ReadonlyMap = new Map([ [ "fs-extra", { @@ -100,6 +105,13 @@ const IMPLEMENTATION_SHIMS: ReadonlyMap = new Map([ mainFile: "index.js", typesFile: "types.d.ts", versions: new Map([[8, "hot-shots/v8.ts"]]), + // hot-shots' uds protocol loads the optional unix-dgram addon: where + // it is installed, the entry with the native Unix datagram transport. + variant: (pkgDir: string) => + installedPackageDir(join(pkgDir, "index.js"), "unix-dgram") === null + ? undefined + : "hot-shots/v8-unix-dgram.ts", + variants: ["hot-shots/v8-unix-dgram.ts"], }, ], [ @@ -164,8 +176,10 @@ export function throughBundledShimForwarder(resolved: string): string { * the guard test that compiles each one. */ export function packageShimEntries(): string[] { const entries = new Set(); - for (const shim of IMPLEMENTATION_SHIMS.values()) + for (const shim of IMPLEMENTATION_SHIMS.values()) { for (const entry of shim.versions.values()) entries.add(join(packageShimRoot(), entry)); + for (const entry of shim.variants ?? []) entries.add(join(packageShimRoot(), entry)); + } return [...entries].sort(); } @@ -263,7 +277,8 @@ function shimEntryForPackageDir(pkgDir: string, expectedName: string | null): st if (shim === undefined) return null; const major = Number(/^(\d+)\./.exec(pkg.version)?.[1] ?? NaN); const entry = shim.versions.get(major); - return entry === undefined ? null : join(packageShimRoot(), entry); + if (entry === undefined) return null; + return join(packageShimRoot(), shim.variant?.(pkgDir) ?? entry); } /** The shim module `specifier` resolves to from `fromFile`, or null. Only @@ -355,6 +370,12 @@ export function isPackageShimFile(fileName: string): boolean { return fileName.startsWith(root.endsWith("/") ? root : `${root}/`); } +/** True for a name a shipped shim may declare as a bodiless runtime + * intrinsic (lower-calls.ts lowers its calls to runtime calls). */ +export function isShimIntrinsicName(name: string): boolean { + return name.startsWith("scriptcUnixDgram"); +} + /** Resets per-compile caches. */ export function clearPackageShimCaches(): void { installedCache.clear(); diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index fcdbe86947..29385db370 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -1528,6 +1528,13 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ }, "dgram.sendStr": { argTypes: [DGRAMSOCK_T, STRING, F64, STRING], result: VOID }, "dgram.sendBytes": { argTypes: [DGRAMSOCK_T, BYTES_U8, F64, STRING], result: VOID }, + /** Connected AF_UNIX datagram sockets for the hot-shots package shim + * (the unix-dgram addon's surface): fd or result >= 0, -errno on + * failure; send answers 1 when the socket would block. */ + "dgram.unixSocket": { argTypes: [], result: F64 }, + "dgram.unixConnect": { argTypes: [F64, STRING], result: F64 }, + "dgram.unixSend": { argTypes: [F64, BYTES_U8], result: F64 }, + "dgram.unixClose": { argTypes: [F64], result: F64 }, /** The send argument-validation ladder over dyn arguments (Node's * signature shuffle: slice bounds, list/type contracts, port/address * validation, connected-state errors), then the send: lists, connected diff --git a/packages/runtime/src/scr_dgram.c b/packages/runtime/src/scr_dgram.c index bb14d063e2..8d1c7b058c 100644 --- a/packages/runtime/src/scr_dgram.c +++ b/packages/runtime/src/scr_dgram.c @@ -2158,3 +2158,73 @@ void scr_dgram_send_chk(ScrDgramSocket *s, const ScrDyn *buffer, const ScrDyn *a * it removes a 'message' listener. Defined last so the functions above * keep their emission order. */ void scr_dgram_rearm(ScrDgramSocket *s) { scr_dgram_update_read(s); } + +/* ── Unix datagram sockets for the hot-shots package shim ────────────── + * The unix-dgram addon's surface, which hot-shots' uds transport uses: a + * non-blocking AF_UNIX datagram socket connected to a path. Each call + * answers its result (fd, 0) or a negative errno, as the addon's binding + * does; send answers 1 when the socket would block (the addon's + * "congestion"). Defined after the functions above so their emission + * order is unchanged. */ +#ifndef _WIN32 +#include +#endif + +double scr_dgram_unix_socket(void) { +#ifdef _WIN32 + return -(double)ENOSYS; +#else + int fd = socket(AF_UNIX, SOCK_DGRAM, 0); + if (fd < 0) return -(double)errno; + int flags = fcntl(fd, F_GETFL, 0); + if (flags >= 0) (void)fcntl(fd, F_SETFL, flags | O_NONBLOCK); + (void)fcntl(fd, F_SETFD, FD_CLOEXEC); + return (double)fd; +#endif +} + +double scr_dgram_unix_connect(double fd, ScrStr *path) { +#ifdef _WIN32 + (void)fd; + (void)path; + return -(double)ENOSYS; +#else + struct sockaddr_un addr; + memset(&addr, 0, sizeof addr); + addr.sun_family = AF_UNIX; + char *owned; + const char *bytes = scr_str_utf8(path, &owned); + size_t n = strlen(bytes); + if (n > sizeof addr.sun_path - 1) n = sizeof addr.sun_path - 1; + memcpy(addr.sun_path, bytes, n); + scr_str_utf8_end(owned); + if (connect((int)fd, (struct sockaddr *)&addr, sizeof addr) != 0) return -(double)errno; + return 0; +#endif +} + +double scr_dgram_unix_send(double fd, ScrBytes *data) { +#ifdef _WIN32 + (void)fd; + (void)data; + return -(double)ENOSYS; +#else + SCR_BYTES_SNAPSHOT(data); + ssize_t sent; + do { + sent = send((int)fd, data->data, data->len, 0); + } while (sent < 0 && errno == EINTR); + if (sent >= 0) return 0; + if (errno == EAGAIN || errno == EWOULDBLOCK) return 1; + return -(double)errno; +#endif +} + +double scr_dgram_unix_close(double fd) { +#ifdef _WIN32 + (void)fd; + return -(double)ENOSYS; +#else + return close((int)fd) != 0 ? -(double)errno : 0; +#endif +} From eef238eb9473ac937c5cf9ed1d1af73cc8930f8c Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Wed, 21 Oct 2026 21:59:20 -0700 Subject: [PATCH 04/23] Pin chalk builder values and buffered hot-shots against Node A callable class instance in a narrower function slot crosses the checked function boundary. New npm cases: chalk5-builder, hot-shots-buffered. Co-Authored-By: Claude Opus 5.5 --- .../compiler/src/frontend/lowering/lowerer.ts | 16 + .../compiler/test/package-shim-guard.test.ts | 3 + .../fixtures/npm/cases/chalk5-builder/main.ts | 45 +++ .../chalk5-builder/node_modules/chalk/license | 9 + .../node_modules/chalk/package.json | 83 +++++ .../node_modules/chalk/source/index.d.ts | 325 ++++++++++++++++++ .../node_modules/chalk/source/index.js | 225 ++++++++++++ .../node_modules/chalk/source/utilities.js | 33 ++ .../source/vendor/ansi-styles/index.d.ts | 236 +++++++++++++ .../chalk/source/vendor/ansi-styles/index.js | 223 ++++++++++++ .../source/vendor/supports-color/browser.d.ts | 1 + .../source/vendor/supports-color/browser.js | 34 ++ .../source/vendor/supports-color/index.d.ts | 55 +++ .../source/vendor/supports-color/index.js | 190 ++++++++++ .../npm/cases/chalk5-builder/package.json | 1 + .../npm/cases/hot-shots-buffered/main.ts | 80 +++++ .../npm/cases/hot-shots-buffered/package.json | 1 + 17 files changed, 1560 insertions(+) create mode 100644 tests/fixtures/npm/cases/chalk5-builder/main.ts create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/license create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/package.json create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/index.d.ts create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/index.js create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/utilities.js create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/ansi-styles/index.d.ts create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/ansi-styles/index.js create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/browser.d.ts create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/browser.js create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/index.d.ts create mode 100644 tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/index.js create mode 100644 tests/fixtures/npm/cases/chalk5-builder/package.json create mode 100644 tests/fixtures/npm/cases/hot-shots-buffered/main.ts create mode 100644 tests/fixtures/npm/cases/hot-shots-buffered/package.json diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index b1867be326..ac1a778cff 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -230,6 +230,7 @@ import { arrayOf, BOOL, canAdaptDynFuncTo, + canBoxFuncIntoDyn, canDynCheckTo, canConvertToDyn, DYN, @@ -9642,6 +9643,21 @@ export class Lowerer { if (expected.kind === "func" && (expr.type.kind === "record" || expr.type.kind === "object")) { const un = this.hybridCallUnwrap(expr); if (un !== expr && typeEquals(un.type, expected)) return un; + // A callable class instance (the chalk shim's variadic builder) in a + // narrower function slot: its call closure crosses the checked + // function boundary, which adapts the arity. + if ( + un !== expr && + expr.type.kind === "object" && + un.type.kind === "func" && + canBoxFuncIntoDyn( + un.type, + (id) => this.shapes.get(id), + (id) => this.unions.get(id), + ) + ) { + return this.coerceToExpected({ kind: "dynFrom", value: un, type: DYN, loc: un.loc }, expected); + } } // A zero-param function whose RETURN is a wider record array than the // slot's (`getRoutes: () => cachedRoutes` against `() => Narrow[]`): diff --git a/packages/compiler/test/package-shim-guard.test.ts b/packages/compiler/test/package-shim-guard.test.ts index ff01acbb8c..a8620c1cef 100644 --- a/packages/compiler/test/package-shim-guard.test.ts +++ b/packages/compiler/test/package-shim-guard.test.ts @@ -49,7 +49,10 @@ describe("package shims compile without refusals", () => { const entries = packageShimEntries(); test("the registry lists its shim modules", () => { expect(entries.map((e) => e.slice(shimRoot.length + 1))).toEqual([ + "chalk/v5.ts", "fs-extra/index.ts", + "hot-shots/v8-unix-dgram.ts", + "hot-shots/v8.ts", "undici/v5.ts", "undici/v7.ts", ]); diff --git a/tests/fixtures/npm/cases/chalk5-builder/main.ts b/tests/fixtures/npm/cases/chalk5-builder/main.ts new file mode 100644 index 0000000000..8f26237179 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/main.ts @@ -0,0 +1,45 @@ +// chalk 5 builders used as values (the package compiles from scriptc's +// built-in shim): builders in function slots and arrays, styles picked at +// run time, visible at level 0, chalkStderr, and the root's own call. +import chalk, { Chalk, chalkStderr, type ChalkInstance, type ForegroundColorName } from "chalk"; + +const show = (label: string, value: string): void => { + console.log(label + " " + JSON.stringify(value)); +}; + +const c = new Chalk({ level: 1 }); +const paint: (text: string) => string = c.green; +show("slot", paint("go")); +const styles: ChalkInstance[] = [c.red, c.bold, c.underline.blue]; +show("array", styles.map((style) => style("x")).join("|")); +const byName = (name: ForegroundColorName): ChalkInstance => { + switch (name) { + case "red": + return c.red; + case "green": + return c.green; + default: + return c.white; + } +}; +show("picked", byName("red")("r") + byName("green")("g") + byName("cyan")("w")); +let chain: ChalkInstance = c; +for (const step of ["bold", "italic", "yellow"]) { + chain = step === "bold" ? chain.bold : step === "italic" ? chain.italic : chain.yellow; +} +show("built", chain("chain")); +show("cached", c.red === c.red ? "same" : "different"); +show("nested close", c.red("a" + c.blue("b") + "c" + c.red("d") + "e")); +show("bg nested", c.bgRed("a" + c.bgBlue("b") + "c")); + +const off = new Chalk({ level: 0 }); +show("visible off", off.visible("v") + "|" + off.red.visible("v") + "|" + off.red("plain")); +show("root call", c("a", 1, true) + "|" + c() + "|" + c(undefined) + "|" + c(null, "n")); +show("builder args", c.red(undefined) + "|" + c.red(null) + "|" + c.red(1, 2) + "|" + c.red()); +show("multiline", c.cyan("one\r\ntwo\nthree")); +show("stderr level", String(chalkStderr.level >= 0)); +show("rgb levels", [1, 2, 3].map((level) => new Chalk({ level: level as 1 | 2 | 3 }).rgb(255, 136, 0)("o")).join("|")); +show("hex bg", new Chalk({ level: 2 }).bgHex("#abcdef")("h") + new Chalk({ level: 1 }).bgHex("123")("i")); +c.level = 0; +show("after level 0", paint("go") + "|" + c.red("r")); +show("default red", chalk.level >= 0 ? "ok" : "bad"); diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/license b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/license new file mode 100644 index 0000000000..fa7ceba3eb --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/package.json b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/package.json new file mode 100644 index 0000000000..c9e0dc52ba --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/package.json @@ -0,0 +1,83 @@ +{ + "name": "chalk", + "version": "5.6.2", + "description": "Terminal string styling done right", + "license": "MIT", + "repository": "chalk/chalk", + "funding": "https://github.com/chalk/chalk?sponsor=1", + "type": "module", + "main": "./source/index.js", + "exports": "./source/index.js", + "imports": { + "#ansi-styles": "./source/vendor/ansi-styles/index.js", + "#supports-color": { + "node": "./source/vendor/supports-color/index.js", + "default": "./source/vendor/supports-color/browser.js" + } + }, + "types": "./source/index.d.ts", + "sideEffects": false, + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "scripts": { + "test": "xo && c8 ava && tsd", + "bench": "matcha benchmark.js" + }, + "files": [ + "source", + "!source/index.test-d.ts" + ], + "keywords": [ + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "string", + "ansi", + "style", + "styles", + "tty", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "log", + "logging", + "command-line", + "text" + ], + "devDependencies": { + "@types/node": "^16.11.10", + "ava": "^3.15.0", + "c8": "^7.10.0", + "color-convert": "^2.0.1", + "execa": "^6.0.0", + "log-update": "^5.0.0", + "matcha": "^0.7.0", + "tsd": "^0.19.0", + "xo": "^0.57.0", + "yoctodelay": "^2.0.0" + }, + "xo": { + "rules": { + "unicorn/prefer-string-slice": "off", + "@typescript-eslint/consistent-type-imports": "off", + "@typescript-eslint/consistent-type-exports": "off", + "@typescript-eslint/consistent-type-definitions": "off", + "unicorn/expiring-todo-comments": "off" + } + }, + "c8": { + "reporter": [ + "text", + "lcov" + ], + "exclude": [ + "source/vendor" + ] + } +} diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/index.d.ts b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/index.d.ts new file mode 100644 index 0000000000..8295d92523 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/index.d.ts @@ -0,0 +1,325 @@ +// TODO: Make it this when TS suports that. +// import {ModifierName, ForegroundColor, BackgroundColor, ColorName} from '#ansi-styles'; +// import {ColorInfo, ColorSupportLevel} from '#supports-color'; +import { + ModifierName, + ForegroundColorName, + BackgroundColorName, + ColorName, +} from './vendor/ansi-styles/index.js'; +import {ColorInfo, ColorSupportLevel} from './vendor/supports-color/index.js'; + +export interface Options { + /** + Specify the color support for Chalk. + + By default, color support is automatically detected based on the environment. + + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + readonly level?: ColorSupportLevel; +} + +/** +Return a new Chalk instance. +*/ +export const Chalk: new (options?: Options) => ChalkInstance; // eslint-disable-line @typescript-eslint/naming-convention + +export interface ChalkInstance { + (...text: unknown[]): string; + + /** + The color support for Chalk. + + By default, color support is automatically detected based on the environment. + + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + level: ColorSupportLevel; + + /** + Use RGB values to set text color. + + @example + ``` + import chalk from 'chalk'; + + chalk.rgb(222, 173, 237); + ``` + */ + rgb: (red: number, green: number, blue: number) => this; + + /** + Use HEX value to set text color. + + @param color - Hexadecimal value representing the desired color. + + @example + ``` + import chalk from 'chalk'; + + chalk.hex('#DEADED'); + ``` + */ + hex: (color: string) => this; + + /** + Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color. + + @example + ``` + import chalk from 'chalk'; + + chalk.ansi256(201); + ``` + */ + ansi256: (index: number) => this; + + /** + Use RGB values to set background color. + + @example + ``` + import chalk from 'chalk'; + + chalk.bgRgb(222, 173, 237); + ``` + */ + bgRgb: (red: number, green: number, blue: number) => this; + + /** + Use HEX value to set background color. + + @param color - Hexadecimal value representing the desired color. + + @example + ``` + import chalk from 'chalk'; + + chalk.bgHex('#DEADED'); + ``` + */ + bgHex: (color: string) => this; + + /** + Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color. + + @example + ``` + import chalk from 'chalk'; + + chalk.bgAnsi256(201); + ``` + */ + bgAnsi256: (index: number) => this; + + /** + Modifier: Reset the current style. + */ + readonly reset: this; + + /** + Modifier: Make the text bold. + */ + readonly bold: this; + + /** + Modifier: Make the text have lower opacity. + */ + readonly dim: this; + + /** + Modifier: Make the text italic. *(Not widely supported)* + */ + readonly italic: this; + + /** + Modifier: Put a horizontal line below the text. *(Not widely supported)* + */ + readonly underline: this; + + /** + Modifier: Put a horizontal line above the text. *(Not widely supported)* + */ + readonly overline: this; + + /** + Modifier: Invert background and foreground colors. + */ + readonly inverse: this; + + /** + Modifier: Print the text but make it invisible. + */ + readonly hidden: this; + + /** + Modifier: Puts a horizontal line through the center of the text. *(Not widely supported)* + */ + readonly strikethrough: this; + + /** + Modifier: Print the text only when Chalk has a color level above zero. + + Can be useful for things that are purely cosmetic. + */ + readonly visible: this; + + readonly black: this; + readonly red: this; + readonly green: this; + readonly yellow: this; + readonly blue: this; + readonly magenta: this; + readonly cyan: this; + readonly white: this; + + /* + Alias for `blackBright`. + */ + readonly gray: this; + + /* + Alias for `blackBright`. + */ + readonly grey: this; + + readonly blackBright: this; + readonly redBright: this; + readonly greenBright: this; + readonly yellowBright: this; + readonly blueBright: this; + readonly magentaBright: this; + readonly cyanBright: this; + readonly whiteBright: this; + + readonly bgBlack: this; + readonly bgRed: this; + readonly bgGreen: this; + readonly bgYellow: this; + readonly bgBlue: this; + readonly bgMagenta: this; + readonly bgCyan: this; + readonly bgWhite: this; + + /* + Alias for `bgBlackBright`. + */ + readonly bgGray: this; + + /* + Alias for `bgBlackBright`. + */ + readonly bgGrey: this; + + readonly bgBlackBright: this; + readonly bgRedBright: this; + readonly bgGreenBright: this; + readonly bgYellowBright: this; + readonly bgBlueBright: this; + readonly bgMagentaBright: this; + readonly bgCyanBright: this; + readonly bgWhiteBright: this; +} + +/** +Main Chalk object that allows to chain styles together. + +Call the last one as a method with a string argument. + +Order doesn't matter, and later styles take precedent in case of a conflict. + +This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`. +*/ +declare const chalk: ChalkInstance; + +export const supportsColor: ColorInfo; + +export const chalkStderr: typeof chalk; +export const supportsColorStderr: typeof supportsColor; + +export { + ModifierName, ForegroundColorName, BackgroundColorName, ColorName, + modifierNames, foregroundColorNames, backgroundColorNames, colorNames, +// } from '#ansi-styles'; +} from './vendor/ansi-styles/index.js'; + +export { + ColorInfo, + ColorSupport, + ColorSupportLevel, +// } from '#supports-color'; +} from './vendor/supports-color/index.js'; + +// TODO: Remove these aliases in the next major version +/** +@deprecated Use `ModifierName` instead. + +Basic modifier names. +*/ +export type Modifiers = ModifierName; + +/** +@deprecated Use `ForegroundColorName` instead. + +Basic foreground color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type ForegroundColor = ForegroundColorName; + +/** +@deprecated Use `BackgroundColorName` instead. + +Basic background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type BackgroundColor = BackgroundColorName; + +/** +@deprecated Use `ColorName` instead. + +Basic color names. The combination of foreground and background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type Color = ColorName; + +/** +@deprecated Use `modifierNames` instead. + +Basic modifier names. +*/ +export const modifiers: readonly Modifiers[]; + +/** +@deprecated Use `foregroundColorNames` instead. + +Basic foreground color names. +*/ +export const foregroundColors: readonly ForegroundColor[]; + +/** +@deprecated Use `backgroundColorNames` instead. + +Basic background color names. +*/ +export const backgroundColors: readonly BackgroundColor[]; + +/** +@deprecated Use `colorNames` instead. + +Basic color names. The combination of foreground and background color names. +*/ +export const colors: readonly Color[]; + +export default chalk; diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/index.js b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/index.js new file mode 100644 index 0000000000..8bc993da5d --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/index.js @@ -0,0 +1,225 @@ +import ansiStyles from '#ansi-styles'; +import supportsColor from '#supports-color'; +import { // eslint-disable-line import/order + stringReplaceAll, + stringEncaseCRLFWithFirstIndex, +} from './utilities.js'; + +const {stdout: stdoutColor, stderr: stderrColor} = supportsColor; + +const GENERATOR = Symbol('GENERATOR'); +const STYLER = Symbol('STYLER'); +const IS_EMPTY = Symbol('IS_EMPTY'); + +// `supportsColor.level` → `ansiStyles.color[name]` mapping +const levelMapping = [ + 'ansi', + 'ansi', + 'ansi256', + 'ansi16m', +]; + +const styles = Object.create(null); + +const applyOptions = (object, options = {}) => { + if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) { + throw new Error('The `level` option should be an integer from 0 to 3'); + } + + // Detect level if not set manually + const colorLevel = stdoutColor ? stdoutColor.level : 0; + object.level = options.level === undefined ? colorLevel : options.level; +}; + +export class Chalk { + constructor(options) { + // eslint-disable-next-line no-constructor-return + return chalkFactory(options); + } +} + +const chalkFactory = options => { + const chalk = (...strings) => strings.join(' '); + applyOptions(chalk, options); + + Object.setPrototypeOf(chalk, createChalk.prototype); + + return chalk; +}; + +function createChalk(options) { + return chalkFactory(options); +} + +Object.setPrototypeOf(createChalk.prototype, Function.prototype); + +for (const [styleName, style] of Object.entries(ansiStyles)) { + styles[styleName] = { + get() { + const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]); + Object.defineProperty(this, styleName, {value: builder}); + return builder; + }, + }; +} + +styles.visible = { + get() { + const builder = createBuilder(this, this[STYLER], true); + Object.defineProperty(this, 'visible', {value: builder}); + return builder; + }, +}; + +const getModelAnsi = (model, level, type, ...arguments_) => { + if (model === 'rgb') { + if (level === 'ansi16m') { + return ansiStyles[type].ansi16m(...arguments_); + } + + if (level === 'ansi256') { + return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_)); + } + + return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_)); + } + + if (model === 'hex') { + return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_)); + } + + return ansiStyles[type][model](...arguments_); +}; + +const usedModels = ['rgb', 'hex', 'ansi256']; + +for (const model of usedModels) { + styles[model] = { + get() { + const {level} = this; + return function (...arguments_) { + const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), ansiStyles.color.close, this[STYLER]); + return createBuilder(this, styler, this[IS_EMPTY]); + }; + }, + }; + + const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1); + styles[bgModel] = { + get() { + const {level} = this; + return function (...arguments_) { + const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), ansiStyles.bgColor.close, this[STYLER]); + return createBuilder(this, styler, this[IS_EMPTY]); + }; + }, + }; +} + +const proto = Object.defineProperties(() => {}, { + ...styles, + level: { + enumerable: true, + get() { + return this[GENERATOR].level; + }, + set(level) { + this[GENERATOR].level = level; + }, + }, +}); + +const createStyler = (open, close, parent) => { + let openAll; + let closeAll; + if (parent === undefined) { + openAll = open; + closeAll = close; + } else { + openAll = parent.openAll + open; + closeAll = close + parent.closeAll; + } + + return { + open, + close, + openAll, + closeAll, + parent, + }; +}; + +const createBuilder = (self, _styler, _isEmpty) => { + // Single argument is hot path, implicit coercion is faster than anything + // eslint-disable-next-line no-implicit-coercion + const builder = (...arguments_) => applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' ')); + + // We alter the prototype because we must return a function, but there is + // no way to create a function with a different prototype + Object.setPrototypeOf(builder, proto); + + builder[GENERATOR] = self; + builder[STYLER] = _styler; + builder[IS_EMPTY] = _isEmpty; + + return builder; +}; + +const applyStyle = (self, string) => { + if (self.level <= 0 || !string) { + return self[IS_EMPTY] ? '' : string; + } + + let styler = self[STYLER]; + + if (styler === undefined) { + return string; + } + + const {openAll, closeAll} = styler; + if (string.includes('\u001B')) { + while (styler !== undefined) { + // Replace any instances already present with a re-opening code + // otherwise only the part of the string until said closing code + // will be colored, and the rest will simply be 'plain'. + string = stringReplaceAll(string, styler.close, styler.open); + + styler = styler.parent; + } + } + + // We can move both next actions out of loop, because remaining actions in loop won't have + // any/visible effect on parts we add here. Close the styling before a linebreak and reopen + // after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92 + const lfIndex = string.indexOf('\n'); + if (lfIndex !== -1) { + string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex); + } + + return openAll + string + closeAll; +}; + +Object.defineProperties(createChalk.prototype, styles); + +const chalk = createChalk(); +export const chalkStderr = createChalk({level: stderrColor ? stderrColor.level : 0}); + +export { + modifierNames, + foregroundColorNames, + backgroundColorNames, + colorNames, + + // TODO: Remove these aliases in the next major version + modifierNames as modifiers, + foregroundColorNames as foregroundColors, + backgroundColorNames as backgroundColors, + colorNames as colors, +} from './vendor/ansi-styles/index.js'; + +export { + stdoutColor as supportsColor, + stderrColor as supportsColorStderr, +}; + +export default chalk; diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/utilities.js b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/utilities.js new file mode 100644 index 0000000000..4366dee0d8 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/utilities.js @@ -0,0 +1,33 @@ +// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`. +export function stringReplaceAll(string, substring, replacer) { + let index = string.indexOf(substring); + if (index === -1) { + return string; + } + + const substringLength = substring.length; + let endIndex = 0; + let returnValue = ''; + do { + returnValue += string.slice(endIndex, index) + substring + replacer; + endIndex = index + substringLength; + index = string.indexOf(substring, endIndex); + } while (index !== -1); + + returnValue += string.slice(endIndex); + return returnValue; +} + +export function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) { + let endIndex = 0; + let returnValue = ''; + do { + const gotCR = string[index - 1] === '\r'; + returnValue += string.slice(endIndex, (gotCR ? index - 1 : index)) + prefix + (gotCR ? '\r\n' : '\n') + postfix; + endIndex = index + 1; + index = string.indexOf('\n', endIndex); + } while (index !== -1); + + returnValue += string.slice(endIndex); + return returnValue; +} diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/ansi-styles/index.d.ts b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/ansi-styles/index.d.ts new file mode 100644 index 0000000000..58f133abe9 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/ansi-styles/index.d.ts @@ -0,0 +1,236 @@ +export interface CSPair { // eslint-disable-line @typescript-eslint/naming-convention + /** + The ANSI terminal control sequence for starting this style. + */ + readonly open: string; + + /** + The ANSI terminal control sequence for ending this style. + */ + readonly close: string; +} + +export interface ColorBase { + /** + The ANSI terminal control sequence for ending this color. + */ + readonly close: string; + + ansi(code: number): string; + + ansi256(code: number): string; + + ansi16m(red: number, green: number, blue: number): string; +} + +export interface Modifier { + /** + Resets the current color chain. + */ + readonly reset: CSPair; + + /** + Make text bold. + */ + readonly bold: CSPair; + + /** + Emitting only a small amount of light. + */ + readonly dim: CSPair; + + /** + Make text italic. (Not widely supported) + */ + readonly italic: CSPair; + + /** + Make text underline. (Not widely supported) + */ + readonly underline: CSPair; + + /** + Make text overline. + + Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash. + */ + readonly overline: CSPair; + + /** + Inverse background and foreground colors. + */ + readonly inverse: CSPair; + + /** + Prints the text, but makes it invisible. + */ + readonly hidden: CSPair; + + /** + Puts a horizontal line through the center of the text. (Not widely supported) + */ + readonly strikethrough: CSPair; +} + +export interface ForegroundColor { + readonly black: CSPair; + readonly red: CSPair; + readonly green: CSPair; + readonly yellow: CSPair; + readonly blue: CSPair; + readonly cyan: CSPair; + readonly magenta: CSPair; + readonly white: CSPair; + + /** + Alias for `blackBright`. + */ + readonly gray: CSPair; + + /** + Alias for `blackBright`. + */ + readonly grey: CSPair; + + readonly blackBright: CSPair; + readonly redBright: CSPair; + readonly greenBright: CSPair; + readonly yellowBright: CSPair; + readonly blueBright: CSPair; + readonly cyanBright: CSPair; + readonly magentaBright: CSPair; + readonly whiteBright: CSPair; +} + +export interface BackgroundColor { + readonly bgBlack: CSPair; + readonly bgRed: CSPair; + readonly bgGreen: CSPair; + readonly bgYellow: CSPair; + readonly bgBlue: CSPair; + readonly bgCyan: CSPair; + readonly bgMagenta: CSPair; + readonly bgWhite: CSPair; + + /** + Alias for `bgBlackBright`. + */ + readonly bgGray: CSPair; + + /** + Alias for `bgBlackBright`. + */ + readonly bgGrey: CSPair; + + readonly bgBlackBright: CSPair; + readonly bgRedBright: CSPair; + readonly bgGreenBright: CSPair; + readonly bgYellowBright: CSPair; + readonly bgBlueBright: CSPair; + readonly bgCyanBright: CSPair; + readonly bgMagentaBright: CSPair; + readonly bgWhiteBright: CSPair; +} + +export interface ConvertColor { + /** + Convert from the RGB color space to the ANSI 256 color space. + + @param red - (`0...255`) + @param green - (`0...255`) + @param blue - (`0...255`) + */ + rgbToAnsi256(red: number, green: number, blue: number): number; + + /** + Convert from the RGB HEX color space to the RGB color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hexToRgb(hex: string): [red: number, green: number, blue: number]; + + /** + Convert from the RGB HEX color space to the ANSI 256 color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hexToAnsi256(hex: string): number; + + /** + Convert from the ANSI 256 color space to the ANSI 16 color space. + + @param code - A number representing the ANSI 256 color. + */ + ansi256ToAnsi(code: number): number; + + /** + Convert from the RGB color space to the ANSI 16 color space. + + @param red - (`0...255`) + @param green - (`0...255`) + @param blue - (`0...255`) + */ + rgbToAnsi(red: number, green: number, blue: number): number; + + /** + Convert from the RGB HEX color space to the ANSI 16 color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hexToAnsi(hex: string): number; +} + +/** +Basic modifier names. +*/ +export type ModifierName = keyof Modifier; + +/** +Basic foreground color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type ForegroundColorName = keyof ForegroundColor; + +/** +Basic background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type BackgroundColorName = keyof BackgroundColor; + +/** +Basic color names. The combination of foreground and background color names. + +[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support) +*/ +export type ColorName = ForegroundColorName | BackgroundColorName; + +/** +Basic modifier names. +*/ +export const modifierNames: readonly ModifierName[]; + +/** +Basic foreground color names. +*/ +export const foregroundColorNames: readonly ForegroundColorName[]; + +/** +Basic background color names. +*/ +export const backgroundColorNames: readonly BackgroundColorName[]; + +/* +Basic color names. The combination of foreground and background color names. +*/ +export const colorNames: readonly ColorName[]; + +declare const ansiStyles: { + readonly modifier: Modifier; + readonly color: ColorBase & ForegroundColor; + readonly bgColor: ColorBase & BackgroundColor; + readonly codes: ReadonlyMap; +} & ForegroundColor & BackgroundColor & Modifier & ConvertColor; + +export default ansiStyles; diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/ansi-styles/index.js b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/ansi-styles/index.js new file mode 100644 index 0000000000..eaa7bed6cb --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/ansi-styles/index.js @@ -0,0 +1,223 @@ +const ANSI_BACKGROUND_OFFSET = 10; + +const wrapAnsi16 = (offset = 0) => code => `\u001B[${code + offset}m`; + +const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`; + +const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`; + +const styles = { + modifier: { + reset: [0, 0], + // 21 isn't widely supported and 22 does the same thing + bold: [1, 22], + dim: [2, 22], + italic: [3, 23], + underline: [4, 24], + overline: [53, 55], + inverse: [7, 27], + hidden: [8, 28], + strikethrough: [9, 29], + }, + color: { + black: [30, 39], + red: [31, 39], + green: [32, 39], + yellow: [33, 39], + blue: [34, 39], + magenta: [35, 39], + cyan: [36, 39], + white: [37, 39], + + // Bright color + blackBright: [90, 39], + gray: [90, 39], // Alias of `blackBright` + grey: [90, 39], // Alias of `blackBright` + redBright: [91, 39], + greenBright: [92, 39], + yellowBright: [93, 39], + blueBright: [94, 39], + magentaBright: [95, 39], + cyanBright: [96, 39], + whiteBright: [97, 39], + }, + bgColor: { + bgBlack: [40, 49], + bgRed: [41, 49], + bgGreen: [42, 49], + bgYellow: [43, 49], + bgBlue: [44, 49], + bgMagenta: [45, 49], + bgCyan: [46, 49], + bgWhite: [47, 49], + + // Bright color + bgBlackBright: [100, 49], + bgGray: [100, 49], // Alias of `bgBlackBright` + bgGrey: [100, 49], // Alias of `bgBlackBright` + bgRedBright: [101, 49], + bgGreenBright: [102, 49], + bgYellowBright: [103, 49], + bgBlueBright: [104, 49], + bgMagentaBright: [105, 49], + bgCyanBright: [106, 49], + bgWhiteBright: [107, 49], + }, +}; + +export const modifierNames = Object.keys(styles.modifier); +export const foregroundColorNames = Object.keys(styles.color); +export const backgroundColorNames = Object.keys(styles.bgColor); +export const colorNames = [...foregroundColorNames, ...backgroundColorNames]; + +function assembleStyles() { + const codes = new Map(); + + for (const [groupName, group] of Object.entries(styles)) { + for (const [styleName, style] of Object.entries(group)) { + styles[styleName] = { + open: `\u001B[${style[0]}m`, + close: `\u001B[${style[1]}m`, + }; + + group[styleName] = styles[styleName]; + + codes.set(style[0], style[1]); + } + + Object.defineProperty(styles, groupName, { + value: group, + enumerable: false, + }); + } + + Object.defineProperty(styles, 'codes', { + value: codes, + enumerable: false, + }); + + styles.color.close = '\u001B[39m'; + styles.bgColor.close = '\u001B[49m'; + + styles.color.ansi = wrapAnsi16(); + styles.color.ansi256 = wrapAnsi256(); + styles.color.ansi16m = wrapAnsi16m(); + styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET); + styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET); + styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET); + + // From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js + Object.defineProperties(styles, { + rgbToAnsi256: { + value(red, green, blue) { + // We use the extended greyscale palette here, with the exception of + // black and white. normal palette only has 4 greyscale shades. + if (red === green && green === blue) { + if (red < 8) { + return 16; + } + + if (red > 248) { + return 231; + } + + return Math.round(((red - 8) / 247) * 24) + 232; + } + + return 16 + + (36 * Math.round(red / 255 * 5)) + + (6 * Math.round(green / 255 * 5)) + + Math.round(blue / 255 * 5); + }, + enumerable: false, + }, + hexToRgb: { + value(hex) { + const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16)); + if (!matches) { + return [0, 0, 0]; + } + + let [colorString] = matches; + + if (colorString.length === 3) { + colorString = [...colorString].map(character => character + character).join(''); + } + + const integer = Number.parseInt(colorString, 16); + + return [ + /* eslint-disable no-bitwise */ + (integer >> 16) & 0xFF, + (integer >> 8) & 0xFF, + integer & 0xFF, + /* eslint-enable no-bitwise */ + ]; + }, + enumerable: false, + }, + hexToAnsi256: { + value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)), + enumerable: false, + }, + ansi256ToAnsi: { + value(code) { + if (code < 8) { + return 30 + code; + } + + if (code < 16) { + return 90 + (code - 8); + } + + let red; + let green; + let blue; + + if (code >= 232) { + red = (((code - 232) * 10) + 8) / 255; + green = red; + blue = red; + } else { + code -= 16; + + const remainder = code % 36; + + red = Math.floor(code / 36) / 5; + green = Math.floor(remainder / 6) / 5; + blue = (remainder % 6) / 5; + } + + const value = Math.max(red, green, blue) * 2; + + if (value === 0) { + return 30; + } + + // eslint-disable-next-line no-bitwise + let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red)); + + if (value === 2) { + result += 60; + } + + return result; + }, + enumerable: false, + }, + rgbToAnsi: { + value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)), + enumerable: false, + }, + hexToAnsi: { + value: hex => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)), + enumerable: false, + }, + }); + + return styles; +} + +const ansiStyles = assembleStyles(); + +export default ansiStyles; diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/browser.d.ts b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/browser.d.ts new file mode 100644 index 0000000000..0e8a9ccb86 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/browser.d.ts @@ -0,0 +1 @@ +export {default} from './index.js'; diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/browser.js b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/browser.js new file mode 100644 index 0000000000..fbb6ce0fc9 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/browser.js @@ -0,0 +1,34 @@ +/* eslint-env browser */ + +const level = (() => { + if (!('navigator' in globalThis)) { + return 0; + } + + if (globalThis.navigator.userAgentData) { + const brand = navigator.userAgentData.brands.find(({brand}) => brand === 'Chromium'); + if (brand && brand.version > 93) { + return 3; + } + } + + if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) { + return 1; + } + + return 0; +})(); + +const colorSupport = level !== 0 && { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3, +}; + +const supportsColor = { + stdout: colorSupport, + stderr: colorSupport, +}; + +export default supportsColor; diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/index.d.ts b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/index.d.ts new file mode 100644 index 0000000000..db44a78519 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/index.d.ts @@ -0,0 +1,55 @@ +import type {WriteStream} from 'node:tty'; + +export type Options = { + /** + Whether `process.argv` should be sniffed for `--color` and `--no-color` flags. + + @default true + */ + readonly sniffFlags?: boolean; +}; + +/** +Levels: +- `0` - All colors disabled. +- `1` - Basic 16 colors support. +- `2` - ANSI 256 colors support. +- `3` - Truecolor 16 million colors support. +*/ +export type ColorSupportLevel = 0 | 1 | 2 | 3; + +/** +Detect whether the terminal supports color. +*/ +export type ColorSupport = { + /** + The color level. + */ + level: ColorSupportLevel; + + /** + Whether basic 16 colors are supported. + */ + hasBasic: boolean; + + /** + Whether ANSI 256 colors are supported. + */ + has256: boolean; + + /** + Whether Truecolor 16 million colors are supported. + */ + has16m: boolean; +}; + +export type ColorInfo = ColorSupport | false; + +export function createSupportsColor(stream?: WriteStream, options?: Options): ColorInfo; + +declare const supportsColor: { + stdout: ColorInfo; + stderr: ColorInfo; +}; + +export default supportsColor; diff --git a/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/index.js b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/index.js new file mode 100644 index 0000000000..265d7f8581 --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/node_modules/chalk/source/vendor/supports-color/index.js @@ -0,0 +1,190 @@ +import process from 'node:process'; +import os from 'node:os'; +import tty from 'node:tty'; + +// From: https://github.com/sindresorhus/has-flag/blob/main/index.js +/// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) { +function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) { + const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--'); + const position = argv.indexOf(prefix + flag); + const terminatorPosition = argv.indexOf('--'); + return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); +} + +const {env} = process; + +let flagForceColor; +if ( + hasFlag('no-color') + || hasFlag('no-colors') + || hasFlag('color=false') + || hasFlag('color=never') +) { + flagForceColor = 0; +} else if ( + hasFlag('color') + || hasFlag('colors') + || hasFlag('color=true') + || hasFlag('color=always') +) { + flagForceColor = 1; +} + +function envForceColor() { + if ('FORCE_COLOR' in env) { + if (env.FORCE_COLOR === 'true') { + return 1; + } + + if (env.FORCE_COLOR === 'false') { + return 0; + } + + return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3); + } +} + +function translateLevel(level) { + if (level === 0) { + return false; + } + + return { + level, + hasBasic: true, + has256: level >= 2, + has16m: level >= 3, + }; +} + +function _supportsColor(haveStream, {streamIsTTY, sniffFlags = true} = {}) { + const noFlagForceColor = envForceColor(); + if (noFlagForceColor !== undefined) { + flagForceColor = noFlagForceColor; + } + + const forceColor = sniffFlags ? flagForceColor : noFlagForceColor; + + if (forceColor === 0) { + return 0; + } + + if (sniffFlags) { + if (hasFlag('color=16m') + || hasFlag('color=full') + || hasFlag('color=truecolor')) { + return 3; + } + + if (hasFlag('color=256')) { + return 2; + } + } + + // Check for Azure DevOps pipelines. + // Has to be above the `!streamIsTTY` check. + if ('TF_BUILD' in env && 'AGENT_NAME' in env) { + return 1; + } + + if (haveStream && !streamIsTTY && forceColor === undefined) { + return 0; + } + + const min = forceColor || 0; + + if (env.TERM === 'dumb') { + return min; + } + + if (process.platform === 'win32') { + // Windows 10 build 10586 is the first Windows release that supports 256 colors. + // Windows 10 build 14931 is the first release that supports 16m/TrueColor. + const osRelease = os.release().split('.'); + if ( + Number(osRelease[0]) >= 10 + && Number(osRelease[2]) >= 10_586 + ) { + return Number(osRelease[2]) >= 14_931 ? 3 : 2; + } + + return 1; + } + + if ('CI' in env) { + if (['GITHUB_ACTIONS', 'GITEA_ACTIONS', 'CIRCLECI'].some(key => key in env)) { + return 3; + } + + if (['TRAVIS', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(sign => sign in env) || env.CI_NAME === 'codeship') { + return 1; + } + + return min; + } + + if ('TEAMCITY_VERSION' in env) { + return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0; + } + + if (env.COLORTERM === 'truecolor') { + return 3; + } + + if (env.TERM === 'xterm-kitty') { + return 3; + } + + if (env.TERM === 'xterm-ghostty') { + return 3; + } + + if (env.TERM === 'wezterm') { + return 3; + } + + if ('TERM_PROGRAM' in env) { + const version = Number.parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10); + + switch (env.TERM_PROGRAM) { + case 'iTerm.app': { + return version >= 3 ? 3 : 2; + } + + case 'Apple_Terminal': { + return 2; + } + // No default + } + } + + if (/-256(color)?$/i.test(env.TERM)) { + return 2; + } + + if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) { + return 1; + } + + if ('COLORTERM' in env) { + return 1; + } + + return min; +} + +export function createSupportsColor(stream, options = {}) { + const level = _supportsColor(stream, { + streamIsTTY: stream && stream.isTTY, + ...options, + }); + + return translateLevel(level); +} + +const supportsColor = { + stdout: createSupportsColor({isTTY: tty.isatty(1)}), + stderr: createSupportsColor({isTTY: tty.isatty(2)}), +}; + +export default supportsColor; diff --git a/tests/fixtures/npm/cases/chalk5-builder/package.json b/tests/fixtures/npm/cases/chalk5-builder/package.json new file mode 100644 index 0000000000..3804daa8df --- /dev/null +++ b/tests/fixtures/npm/cases/chalk5-builder/package.json @@ -0,0 +1 @@ +{ "name": "chalk5-case", "private": true, "type": "module" } diff --git a/tests/fixtures/npm/cases/hot-shots-buffered/main.ts b/tests/fixtures/npm/cases/hot-shots-buffered/main.ts new file mode 100644 index 0000000000..d17ce11678 --- /dev/null +++ b/tests/fixtures/npm/cases/hot-shots-buffered/main.ts @@ -0,0 +1,80 @@ +// The hot-shots StatsD client (compiled from scriptc's built-in shim) in +// buffered mode: metrics join one datagram until maxBufferSize, close +// flushes the rest, child clients share the buffer. Also explicit sample +// rates of 1, the telegraf line format, stat arrays with a callback, and +// suffixes. +import * as dgram from "node:dgram"; +import { StatsD } from "hot-shots"; + +const server = dgram.createSocket("udp4"); +const received: string[] = []; +let waiting: (() => void) | null = null; +let want = 0; +server.on("message", (msg) => { + received.push(msg.toString()); + if (waiting !== null && received.length >= want) { + const done = waiting; + waiting = null; + done(); + } +}); + +function datagrams(count: number): Promise { + want = count; + return new Promise((resolve) => { + if (received.length >= want) resolve(); + else waiting = resolve; + }); +} + +function flush(label: string): void { + console.log("--", label); + for (const line of received.splice(0)) console.log(JSON.stringify(line)); +} + +async function run(port: number): Promise { + const buffered = new StatsD({ + host: "127.0.0.1", + port, + maxBufferSize: 64, + bufferFlushInterval: 60000, + suffix: ".s", + globalTags: ["team:core"], + }); + buffered.increment("one"); + buffered.increment("two", 2); + buffered.gauge("three", 3); + buffered.histogram("four", 4, ["h:1"]); + const child = buffered.childClient({ prefix: "kid.", suffix: ".x" }); + child.increment("five"); + await new Promise((resolve) => buffered.close(() => resolve())); + await datagrams(2); + flush("buffered"); + + const telegraf = new StatsD({ host: "127.0.0.1", port, telegraf: true, globalTags: { region: "eu" } }); + telegraf.increment("hits", 1, 1, { route: "/x" }); + telegraf.timing("lat", 7, ["kind:a"]); + await datagrams(2); + flush("telegraf"); + + const plain = new StatsD({ host: "127.0.0.1", port, prefix: "p." }); + await new Promise((resolve) => { + plain.increment(["a", "b", "c"], 1, 1, ["t:1"], (err: unknown, bytes: unknown) => { + console.log("array sent", err, bytes); + resolve(); + }); + }); + plain.set("users", 42, 1); + plain.unique("visitors", "v1"); + plain.decrement("down", 3, ["d:1"]); + plain.decrement("gone"); + await datagrams(7); + flush("plain"); + await new Promise((resolve) => { + telegraf.close(() => plain.close(() => resolve())); + }); +} + +server.bind(0, "127.0.0.1", () => { + void run(server.address().port).then(() => server.close(() => console.log("server closed"))); +}); diff --git a/tests/fixtures/npm/cases/hot-shots-buffered/package.json b/tests/fixtures/npm/cases/hot-shots-buffered/package.json new file mode 100644 index 0000000000..5ffd9800b9 --- /dev/null +++ b/tests/fixtures/npm/cases/hot-shots-buffered/package.json @@ -0,0 +1 @@ +{ "type": "module" } From 6de7864697c5b49f90be08694b6104b2987d0b58 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Wed, 21 Oct 2026 22:00:42 -0700 Subject: [PATCH 05/23] Record order baselines for the new chalk and hot-shots npm cases Co-Authored-By: Claude Opus 5.5 --- .../tests/fixtures/npm/cases/chalk5-builder/main.ts.json | 6 ++++++ .../fixtures/npm/cases/hot-shots-buffered/main.ts.json | 6 ++++++ 2 files changed, 12 insertions(+) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5-builder/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-buffered/main.ts.json diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5-builder/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5-builder/main.ts.json new file mode 100644 index 0000000000..545c4d701c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5-builder/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/chalk5-builder/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-buffered/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-buffered/main.ts.json new file mode 100644 index 0000000000..e60660c09a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-buffered/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/hot-shots-buffered/main.ts" + ], + "diags": [] +} From 284517accbfd37cd06c87a5a352fe8b43acf10f8 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Wed, 21 Oct 2026 22:04:27 -0700 Subject: [PATCH 06/23] Call chalk builders with one string through a typed method A callable class's %call1 method takes a single string argument directly, skipping the variadic closure's checked-dynamic call. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/shims/chalk/v5.ts | 8 ++++ .../src/frontend/lowering/lower-calls.ts | 42 +++++++++++++++++++ 2 files changed, 50 insertions(+) diff --git a/packages/compiler/shims/chalk/v5.ts b/packages/compiler/shims/chalk/v5.ts index 6599e35f93..494a9c69f7 100644 --- a/packages/compiler/shims/chalk/v5.ts +++ b/packages/compiler/shims/chalk/v5.ts @@ -435,12 +435,14 @@ export class ChalkInstance { box: LevelBox; styler: Styler | undefined; isEmpty: boolean; + private readonly root: boolean; private readonly cache: (ChalkInstance | undefined)[] = []; constructor(box: LevelBox, styler: Styler | undefined, isEmpty: boolean, root: boolean) { this.box = box; this.styler = styler; this.isEmpty = isEmpty; + this.root = root; // One unconditional store: the field's definite assignment. this["%call"] = (...text: unknown[]): string => root @@ -448,6 +450,12 @@ export class ChalkInstance { : applyStyle(this, text.length === 1 ? "" + String(text[0]) : joinArguments(text)); } + /** One string argument: the compiler calls this instead of `%call` + * (no variadic arguments to box). */ + "%call1"(text: string): string { + return this.root ? text : applyStyle(this, text); + } + get level(): ColorSupportLevel { return this.box.level as ColorSupportLevel; } diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 3c04924c0b..9d6f477f64 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -1632,6 +1632,8 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr { // A getter returning a callable class instance (chalk's // `chalk.red("x")`): call through its `%call` field. if (callee.type.kind === "object") { + const direct = callableInstanceStringCall(lowerer, expr, callee, locOf(expr)); + if (direct) return direct; callee = lowerer.hybridCallUnwrap(callee); if (callee.type.kind === "func") return lowerCallThroughValue(lowerer, expr, callee, locOf(expr)); } @@ -1886,11 +1888,47 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr { // a non-func IR type was already rejected while lowering the callee. // HYBRID (function-with-properties) values call through their %call slot. let callee = lowerer.lowerExpr(expr.expression); + { + const direct = callableInstanceStringCall(lowerer, expr, callee, loc); + if (direct) return direct; + } if (callee.type.kind === "record" || callee.type.kind === "object") callee = lowerer.hybridCallUnwrap(callee); return lowerCallThroughValue(lowerer, expr, callee, loc); } +/** A callable class instance called with one string: its `%call1` method + * when the class has one (the chalk shim's typed fast path), skipping the + * variadic closure's checked-dynamic arguments. */ +function callableInstanceStringCall( + lowerer: Lowerer, + expr: ts.CallExpression, + callee: IrExpr, + loc: SrcLoc, +): IrExpr | null { + if (callee.type.kind !== "object" || expr.arguments.nodes.length !== 1) return null; + const arg = expr.arguments.nodes[0]!; + if (ts.isSpreadElement(arg)) return null; + const info = lowerer.classes.get(callee.type.className); + if (info === undefined || !info.fields.has("%call") || !lowerer.findMethodOn(info, "%call1")) + return null; + const value = lowerer.lowerExpr(arg); + if (value.type.kind === "string") + return lowerer.accessorCall(callee.type.className, "%call1", callee, [value], STRING, loc); + // Any other argument (a number behind a cast): the variadic closure, + // through the checked-dynamic call as lowerCallThroughValue would. + const closure = lowerer.hybridCallUnwrap(callee); + if (closure.type.kind !== "func") return null; + return { + kind: "dynCall", + callee: { kind: "dynFrom", value: closure, type: DYN, loc }, + calleeName: ts.isIdentifier(expr.expression) ? expr.expression.text : "value", + args: [lowerer.coerceToExpected(value, DYN)], + type: DYN, + loc, + }; +} + /** A call through an evaluated callee value: checked-dynamic callees, * function unions, typed-rest and runtime-arity closures. */ function lowerCallThroughValue( @@ -9208,6 +9246,10 @@ export function lowerRecordFieldCall( // A HYBRID (function-with-properties) field is callable through its // reserved %call slot — `colors.blue("x")` where blue also carries // `.bold` (the chalk shape). + if (callee.type.kind === "object" && !init) { + const direct = callableInstanceStringCall(lowerer, call, callee, loc); + if (direct) return direct; + } if (callee.type.kind === "record" || callee.type.kind === "object") callee = lowerer.hybridCallUnwrap(callee); // Inferred JavaScript option records can retain checked callables in From 88f9ba91eb94d63c254bc934beaaeb5dd887ea7e Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Wed, 21 Oct 2026 22:08:46 -0700 Subject: [PATCH 07/23] Format the shims and scope the chalk declaration-merge lint exception Co-Authored-By: Claude Opus 5.5 --- packages/compiler/shims/chalk/v5.ts | 241 +++++++++++++----- packages/compiler/shims/hot-shots/client.ts | 85 +++++- .../src/frontend/lowering/lower-calls.ts | 3 +- .../compiler/src/frontend/lowering/lowerer.ts | 5 +- .../compiler/src/frontend/package-shims.ts | 8 +- 5 files changed, 260 insertions(+), 82 deletions(-) diff --git a/packages/compiler/shims/chalk/v5.ts b/packages/compiler/shims/chalk/v5.ts index 494a9c69f7..2d34c5c532 100644 --- a/packages/compiler/shims/chalk/v5.ts +++ b/packages/compiler/shims/chalk/v5.ts @@ -138,10 +138,7 @@ export const backgroundColorNames: BackgroundColorName[] = [ "bgCyanBright", "bgWhiteBright", ]; -export const colorNames: ColorName[] = [ - ...foregroundColorNames, - ...backgroundColorNames, -]; +export const colorNames: ColorName[] = [...foregroundColorNames, ...backgroundColorNames]; export const modifiers: Modifiers[] = modifierNames; export const foregroundColors: ForegroundColor[] = foregroundColorNames; export const backgroundColors: BackgroundColor[] = backgroundColorNames; @@ -151,14 +148,12 @@ const ESC = "\u001B["; /** Open and close codes, indexed by style id (the order of the getters). */ const OPEN_CODES: number[] = [ - 0, 1, 2, 3, 4, 53, 7, 8, 9, - 30, 31, 32, 33, 34, 35, 36, 37, 90, 90, 90, 91, 92, 93, 94, 95, 96, 97, - 40, 41, 42, 43, 44, 45, 46, 47, 100, 100, 100, 101, 102, 103, 104, 105, 106, 107, + 0, 1, 2, 3, 4, 53, 7, 8, 9, 30, 31, 32, 33, 34, 35, 36, 37, 90, 90, 90, 91, 92, 93, 94, 95, 96, + 97, 40, 41, 42, 43, 44, 45, 46, 47, 100, 100, 100, 101, 102, 103, 104, 105, 106, 107, ]; const CLOSE_CODES: number[] = [ - 0, 22, 22, 23, 24, 55, 27, 28, 29, - 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, - 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, + 0, 22, 22, 23, 24, 55, 27, 28, 29, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, + 39, 39, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, ]; const VISIBLE = 45; @@ -238,9 +233,19 @@ function hasFlag(flag: string): boolean { } let flagForceColor: number | undefined = undefined; -if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) { +if ( + hasFlag("no-color") || + hasFlag("no-colors") || + hasFlag("color=false") || + hasFlag("color=never") +) { flagForceColor = 0; -} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) { +} else if ( + hasFlag("color") || + hasFlag("colors") || + hasFlag("color=true") || + hasFlag("color=always") +) { flagForceColor = 1; } @@ -277,7 +282,8 @@ function detectLevel(streamIsTTY: boolean): number { if (hasFlag("color=256")) return 2; if (inEnv("TF_BUILD") && inEnv("AGENT_NAME")) return 1; if (!streamIsTTY && forceColor === undefined) return 0; - const min = forceColor === undefined || forceColor === 0 || Number.isNaN(forceColor) ? 0 : forceColor; + const min = + forceColor === undefined || forceColor === 0 || Number.isNaN(forceColor) ? 0 : forceColor; const env = process.env; const term = env["TERM"]; if (term === "dumb") return min; @@ -388,7 +394,10 @@ function stringEncaseCRLFWithFirstIndex( do { const gotCR = string[index - 1] === "\r"; returnValue += - string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix; + string.slice(endIndex, gotCR ? index - 1 : index) + + prefix + + (gotCR ? "\r\n" : "\n") + + postfix; endIndex = index + 1; index = string.indexOf("\n", endIndex); } while (index !== -1); @@ -426,12 +435,19 @@ function joinArguments(args: unknown[]): string { /** A chalk instance or one of its style chains: callable (chalk's call * signature merges in from the interface), with every style a cached * getter. */ +// The merge is the point: the interface gives instances chalk's call +// signature, and the class's `%call` field implements it. +// oxlint-disable-next-line typescript/no-unsafe-declaration-merging export interface ChalkInstance { (...text: unknown[]): string; } +// oxlint-disable-next-line typescript/no-unsafe-declaration-merging export class ChalkInstance { - "%call": (...text: unknown[]) => string; + "%call": (...text: unknown[]) => string = (...text: unknown[]): string => + this.root + ? joinArguments(text) + : applyStyle(this, text.length === 1 ? "" + String(text[0]) : joinArguments(text)); box: LevelBox; styler: Styler | undefined; isEmpty: boolean; @@ -443,11 +459,6 @@ export class ChalkInstance { this.styler = styler; this.isEmpty = isEmpty; this.root = root; - // One unconditional store: the field's definite assignment. - this["%call"] = (...text: unknown[]): string => - root - ? joinArguments(text) - : applyStyle(this, text.length === 1 ? "" + String(text[0]) : joinArguments(text)); } /** One string argument: the compiler calls this instead of `%call` @@ -509,57 +520,153 @@ export class ChalkInstance { return this.model(ansi256Open(10, index), true); } - get reset(): ChalkInstance { return this.style(0); } - get bold(): ChalkInstance { return this.style(1); } - get dim(): ChalkInstance { return this.style(2); } - get italic(): ChalkInstance { return this.style(3); } - get underline(): ChalkInstance { return this.style(4); } - get overline(): ChalkInstance { return this.style(5); } - get inverse(): ChalkInstance { return this.style(6); } - get hidden(): ChalkInstance { return this.style(7); } - get strikethrough(): ChalkInstance { return this.style(8); } - get visible(): ChalkInstance { return this.style(VISIBLE); } - get black(): ChalkInstance { return this.style(9); } - get red(): ChalkInstance { return this.style(10); } - get green(): ChalkInstance { return this.style(11); } - get yellow(): ChalkInstance { return this.style(12); } - get blue(): ChalkInstance { return this.style(13); } - get magenta(): ChalkInstance { return this.style(14); } - get cyan(): ChalkInstance { return this.style(15); } - get white(): ChalkInstance { return this.style(16); } - get blackBright(): ChalkInstance { return this.style(17); } - get gray(): ChalkInstance { return this.style(18); } - get grey(): ChalkInstance { return this.style(19); } - get redBright(): ChalkInstance { return this.style(20); } - get greenBright(): ChalkInstance { return this.style(21); } - get yellowBright(): ChalkInstance { return this.style(22); } - get blueBright(): ChalkInstance { return this.style(23); } - get magentaBright(): ChalkInstance { return this.style(24); } - get cyanBright(): ChalkInstance { return this.style(25); } - get whiteBright(): ChalkInstance { return this.style(26); } - get bgBlack(): ChalkInstance { return this.style(27); } - get bgRed(): ChalkInstance { return this.style(28); } - get bgGreen(): ChalkInstance { return this.style(29); } - get bgYellow(): ChalkInstance { return this.style(30); } - get bgBlue(): ChalkInstance { return this.style(31); } - get bgMagenta(): ChalkInstance { return this.style(32); } - get bgCyan(): ChalkInstance { return this.style(33); } - get bgWhite(): ChalkInstance { return this.style(34); } - get bgBlackBright(): ChalkInstance { return this.style(35); } - get bgGray(): ChalkInstance { return this.style(36); } - get bgGrey(): ChalkInstance { return this.style(37); } - get bgRedBright(): ChalkInstance { return this.style(38); } - get bgGreenBright(): ChalkInstance { return this.style(39); } - get bgYellowBright(): ChalkInstance { return this.style(40); } - get bgBlueBright(): ChalkInstance { return this.style(41); } - get bgMagentaBright(): ChalkInstance { return this.style(42); } - get bgCyanBright(): ChalkInstance { return this.style(43); } - get bgWhiteBright(): ChalkInstance { return this.style(44); } + get reset(): ChalkInstance { + return this.style(0); + } + get bold(): ChalkInstance { + return this.style(1); + } + get dim(): ChalkInstance { + return this.style(2); + } + get italic(): ChalkInstance { + return this.style(3); + } + get underline(): ChalkInstance { + return this.style(4); + } + get overline(): ChalkInstance { + return this.style(5); + } + get inverse(): ChalkInstance { + return this.style(6); + } + get hidden(): ChalkInstance { + return this.style(7); + } + get strikethrough(): ChalkInstance { + return this.style(8); + } + get visible(): ChalkInstance { + return this.style(VISIBLE); + } + get black(): ChalkInstance { + return this.style(9); + } + get red(): ChalkInstance { + return this.style(10); + } + get green(): ChalkInstance { + return this.style(11); + } + get yellow(): ChalkInstance { + return this.style(12); + } + get blue(): ChalkInstance { + return this.style(13); + } + get magenta(): ChalkInstance { + return this.style(14); + } + get cyan(): ChalkInstance { + return this.style(15); + } + get white(): ChalkInstance { + return this.style(16); + } + get blackBright(): ChalkInstance { + return this.style(17); + } + get gray(): ChalkInstance { + return this.style(18); + } + get grey(): ChalkInstance { + return this.style(19); + } + get redBright(): ChalkInstance { + return this.style(20); + } + get greenBright(): ChalkInstance { + return this.style(21); + } + get yellowBright(): ChalkInstance { + return this.style(22); + } + get blueBright(): ChalkInstance { + return this.style(23); + } + get magentaBright(): ChalkInstance { + return this.style(24); + } + get cyanBright(): ChalkInstance { + return this.style(25); + } + get whiteBright(): ChalkInstance { + return this.style(26); + } + get bgBlack(): ChalkInstance { + return this.style(27); + } + get bgRed(): ChalkInstance { + return this.style(28); + } + get bgGreen(): ChalkInstance { + return this.style(29); + } + get bgYellow(): ChalkInstance { + return this.style(30); + } + get bgBlue(): ChalkInstance { + return this.style(31); + } + get bgMagenta(): ChalkInstance { + return this.style(32); + } + get bgCyan(): ChalkInstance { + return this.style(33); + } + get bgWhite(): ChalkInstance { + return this.style(34); + } + get bgBlackBright(): ChalkInstance { + return this.style(35); + } + get bgGray(): ChalkInstance { + return this.style(36); + } + get bgGrey(): ChalkInstance { + return this.style(37); + } + get bgRedBright(): ChalkInstance { + return this.style(38); + } + get bgGreenBright(): ChalkInstance { + return this.style(39); + } + get bgYellowBright(): ChalkInstance { + return this.style(40); + } + get bgBlueBright(): ChalkInstance { + return this.style(41); + } + get bgMagentaBright(): ChalkInstance { + return this.style(42); + } + get bgCyanBright(): ChalkInstance { + return this.style(43); + } + get bgWhiteBright(): ChalkInstance { + return this.style(44); + } } function optionsLevel(options: Options | undefined): number { const level = options === undefined ? undefined : options.level; - if (level !== undefined && level !== 0 && !(Number.isInteger(level) && level >= 0 && level <= 3)) { + if ( + level !== undefined && + level !== 0 && + !(Number.isInteger(level) && level >= 0 && level <= 3) + ) { throw new Error("The `level` option should be an integer from 0 to 3"); } if (level === undefined) return stdoutColor === false ? 0 : stdoutColor.level; diff --git a/packages/compiler/shims/hot-shots/client.ts b/packages/compiler/shims/hot-shots/client.ts index d0b5c8924d..2f8ca05804 100644 --- a/packages/compiler/shims/hot-shots/client.ts +++ b/packages/compiler/shims/hot-shots/client.ts @@ -542,7 +542,13 @@ export class StatsD { // ── stats functions ── - timing(stat: string | string[], time: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + timing( + stat: string | string[], + time: number, + sampleRate?: number, + tags?: Tags, + callback?: StatsCb, + ): void; timing(stat: string | string[], time: number, tags?: Tags, callback?: StatsCb): void; timing(stat: string | string[], time: number, callback?: StatsCb): void; timing(stat: string | string[], time: number, sampleRate?: number, callback?: StatsCb): void; @@ -557,7 +563,13 @@ export class StatsD { } increment(stat: string, tags?: Tags): void; - increment(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + increment( + stat: string | string[], + value: number, + sampleRate?: number, + tags?: Tags, + callback?: StatsCb, + ): void; increment(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; increment(stat: string | string[], value: number, callback?: StatsCb): void; increment(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; @@ -580,7 +592,13 @@ export class StatsD { } decrement(stat: string, tags?: Tags): void; - decrement(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + decrement( + stat: string | string[], + value: number, + sampleRate?: number, + tags?: Tags, + callback?: StatsCb, + ): void; decrement(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; decrement(stat: string | string[], value: number, callback?: StatsCb): void; decrement(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; @@ -601,7 +619,13 @@ export class StatsD { this.sendAll(stat, -amount, "c", sampleRate, tagArg, callback); } - histogram(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + histogram( + stat: string | string[], + value: number, + sampleRate?: number, + tags?: Tags, + callback?: StatsCb, + ): void; histogram(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; histogram(stat: string | string[], value: number, callback?: StatsCb): void; histogram(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; @@ -615,10 +639,21 @@ export class StatsD { this.sendAll(stat, value, "h", sampleRate, tags, callback); } - distribution(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + distribution( + stat: string | string[], + value: number, + sampleRate?: number, + tags?: Tags, + callback?: StatsCb, + ): void; distribution(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; distribution(stat: string | string[], value: number, callback?: StatsCb): void; - distribution(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; + distribution( + stat: string | string[], + value: number, + sampleRate?: number, + callback?: StatsCb, + ): void; distribution( stat: string | string[], value: number, @@ -629,7 +664,13 @@ export class StatsD { this.sendAll(stat, value, "d", sampleRate, tags, callback); } - gauge(stat: string | string[], value: number, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + gauge( + stat: string | string[], + value: number, + sampleRate?: number, + tags?: Tags, + callback?: StatsCb, + ): void; gauge(stat: string | string[], value: number, tags?: Tags, callback?: StatsCb): void; gauge(stat: string | string[], value: number, callback?: StatsCb): void; gauge(stat: string | string[], value: number, sampleRate?: number, callback?: StatsCb): void; @@ -643,10 +684,21 @@ export class StatsD { this.sendAll(stat, value, "g", sampleRate, tags, callback); } - set(stat: string | string[], value: number | string, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + set( + stat: string | string[], + value: number | string, + sampleRate?: number, + tags?: Tags, + callback?: StatsCb, + ): void; set(stat: string | string[], value: number | string, tags?: Tags, callback?: StatsCb): void; set(stat: string | string[], value: number | string, callback?: StatsCb): void; - set(stat: string | string[], value: number | string, sampleRate?: number, callback?: StatsCb): void; + set( + stat: string | string[], + value: number | string, + sampleRate?: number, + callback?: StatsCb, + ): void; set( stat: string | string[], value: number | string, @@ -657,10 +709,21 @@ export class StatsD { this.sendAll(stat, value, "s", sampleRate, tags, callback); } - unique(stat: string | string[], value: number | string, sampleRate?: number, tags?: Tags, callback?: StatsCb): void; + unique( + stat: string | string[], + value: number | string, + sampleRate?: number, + tags?: Tags, + callback?: StatsCb, + ): void; unique(stat: string | string[], value: number | string, tags?: Tags, callback?: StatsCb): void; unique(stat: string | string[], value: number | string, callback?: StatsCb): void; - unique(stat: string | string[], value: number | string, sampleRate?: number, callback?: StatsCb): void; + unique( + stat: string | string[], + value: number | string, + sampleRate?: number, + callback?: StatsCb, + ): void; unique( stat: string | string[], value: number | string, diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 9d6f477f64..b650ca5672 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -1635,7 +1635,8 @@ export function lowerCall(lowerer: Lowerer, expr: ts.CallExpression): IrExpr { const direct = callableInstanceStringCall(lowerer, expr, callee, locOf(expr)); if (direct) return direct; callee = lowerer.hybridCallUnwrap(callee); - if (callee.type.kind === "func") return lowerCallThroughValue(lowerer, expr, callee, locOf(expr)); + if (callee.type.kind === "func") + return lowerCallThroughValue(lowerer, expr, callee, locOf(expr)); } if (callee.type.kind === "func") { const args = completeFuncValueArgs(lowerer, expr, callee.type, locOf(expr)); diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index ac1a778cff..206c42fdce 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -9656,7 +9656,10 @@ export class Lowerer { (id) => this.unions.get(id), ) ) { - return this.coerceToExpected({ kind: "dynFrom", value: un, type: DYN, loc: un.loc }, expected); + return this.coerceToExpected( + { kind: "dynFrom", value: un, type: DYN, loc: un.loc }, + expected, + ); } } // A zero-param function whose RETURN is a wider record array than the diff --git a/packages/compiler/src/frontend/package-shims.ts b/packages/compiler/src/frontend/package-shims.ts index 3af7ebf594..a0c2e4cb96 100644 --- a/packages/compiler/src/frontend/package-shims.ts +++ b/packages/compiler/src/frontend/package-shims.ts @@ -72,7 +72,10 @@ interface ImplementationShim { variants?: readonly string[]; } -const IMPLEMENTATION_SHIMS: ReadonlyMap = new Map([ +const IMPLEMENTATION_SHIMS: ReadonlyMap = new Map< + string, + ImplementationShim +>([ [ "fs-extra", { @@ -330,7 +333,8 @@ function shimOfDeclarationPath(path: string): { pkgDir: string; shim: Implementa for (const shim of IMPLEMENTATION_SHIMS.values()) { if (shim.typesFile === undefined) continue; const suffix = `/${shim.name}/${shim.typesFile}`; - if (path.endsWith(suffix)) return { pkgDir: path.slice(0, path.length - suffix.length + shim.name.length + 1), shim }; + if (path.endsWith(suffix)) + return { pkgDir: path.slice(0, path.length - suffix.length + shim.name.length + 1), shim }; } return null; } From 8c9f5cfc9ff02dccb7a97266d210bfba559a5ccc Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Thu, 22 Oct 2026 01:42:01 -0700 Subject: [PATCH 08/23] Free hot-shots' unclosed udp and tcp transports at exit The socket's error listener captured the transport, so a client that is never closed (mock mode) kept a cycle the RC audit reports at exit; it now captures only the listener list. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/shims/hot-shots/client.ts | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/packages/compiler/shims/hot-shots/client.ts b/packages/compiler/shims/hot-shots/client.ts index 2f8ca05804..aa752d703c 100644 --- a/packages/compiler/shims/hot-shots/client.ts +++ b/packages/compiler/shims/hot-shots/client.ts @@ -218,7 +218,11 @@ class UdpTransport implements Transport { this.cacheDnsTtl = cacheDnsTtl; this.socket = dgram.createSocket("udp4"); this.socket.unref(); - this.socket.on("error", (err) => this.errors.emit(err)); + // The listener captures the list, not the transport: a socket that is + // never closed keeps its listener, and a capture of `this` would make + // a cycle the reference counts cannot free at exit. + const errors = this.errors; + this.socket.on("error", (err) => errors.emit(err)); } send(buf: Buffer, callback: SendCallback): void { if (!this.cacheDns) { @@ -263,7 +267,11 @@ class TcpTransport implements Transport { this.socket = net.connect(port, host ?? "localhost"); this.socket.setKeepAlive(true); this.socket.unref(); - this.socket.on("error", (err) => this.errors.emit(err)); + // The listener captures the list, not the transport: a socket that is + // never closed keeps its listener, and a capture of `this` would make + // a cycle the reference counts cannot free at exit. + const errors = this.errors; + this.socket.on("error", (err) => errors.emit(err)); } send(buf: Buffer, callback: SendCallback): void { // The typed socket's write takes the data alone; the completion runs From 2e297caf9955cf8cb4606c9acd7dda8f3eac5877 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Thu, 22 Oct 2026 05:33:34 -0700 Subject: [PATCH 09/23] Log hot-shots' failed final flush through an unknown value Programs whose Error subclasses define accessors still compile the shim's close logging. Co-Authored-By: Claude Opus 5.5 --- packages/compiler/shims/hot-shots/client.ts | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/packages/compiler/shims/hot-shots/client.ts b/packages/compiler/shims/hot-shots/client.ts index aa752d703c..b407132f47 100644 --- a/packages/compiler/shims/hot-shots/client.ts +++ b/packages/compiler/shims/hot-shots/client.ts @@ -155,6 +155,13 @@ function formatDate(date: number): number { return Math.round(date); } +/** console.error of an arbitrary value, as hot-shots logs errors. The + * value crosses as unknown: the typed Error path has no inspect lowering + * in programs whose Error subclasses define accessors. */ +function logError(value: unknown): void { + console.error(value); +} + function errorWithCode(message: string, code: string | undefined): Error { const error: NodeJS.ErrnoException = new Error(message); error.code = code; @@ -1013,7 +1020,7 @@ export class StatsD { this.flushQueue((err) => { if (err) { if (callback) return callback(err); - console.error(err); + logError(err); return; } let intervalAttempts = 0; From 164174f811a2f0f927fde6f76f5578c6ff538139 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Thu, 22 Oct 2026 02:29:47 -0700 Subject: [PATCH 10/23] Keep literal key order for records a narrowing throw arm types The key-order witness pass read every libCall typed as a record as an opaque producer of that record, which pins the declaration order. A void runtime call typed by its use site, such as error.nodeThrow in the ternary that narrows a possibly-undefined binding before a member read, never produces a value. A module-level accumulator enumerated in its interface's order instead of its literal's. New corpus program 6915. Co-Authored-By: Claude Opus 5.5 --- .../frontend/lowering/key-order-witness.ts | 6 +- .../6915-key-order-narrowed-throw.ts.json | 6 ++ tests/corpus/6915-key-order-narrowed-throw.ts | 72 +++++++++++++++++++ .../6915-key-order-narrowed-throw.ts.json | 1 + 4 files changed, 84 insertions(+), 1 deletion(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6915-key-order-narrowed-throw.ts.json create mode 100644 tests/corpus/6915-key-order-narrowed-throw.ts create mode 100644 tests/harness/corpus-costs/6915-key-order-narrowed-throw.ts.json diff --git a/packages/compiler/src/frontend/lowering/key-order-witness.ts b/packages/compiler/src/frontend/lowering/key-order-witness.ts index 2fc9a6cbda..7ce8ae074a 100644 --- a/packages/compiler/src/frontend/lowering/key-order-witness.ts +++ b/packages/compiler/src/frontend/lowering/key-order-witness.ts @@ -45,6 +45,7 @@ import type { IrExpr, IrFunction, IrRecordShape, IrStmt, IrType } from "../../ir import { shapeHasAccessorSlots, typeEquals, UNDEFINED_T } from "../../ir/ir.js"; import { everyExprChild, everyStmtChild, everyTypeChild } from "../../ir/traverse.js"; import type { Lowerer } from "./lowerer.js"; +import { LIB_FN_SIGS } from "../../ir/builtin-signatures.js"; /** One property of an object literal, in source order. */ export type KeyOrderSegment = @@ -312,7 +313,10 @@ export function applyKeyOrderWitnesses(lowerer: Lowerer, fns: readonly IrFunctio // Runtime surfaces (console, util.format, workers) that take a // record may walk its keys; runtime builders make new records. for (const arg of e.args) observedRoots.push(arg.type); - producedBy(e.type, true); + // A void runtime call typed by its use site is a throw standing in + // for a value (`error.nodeThrow` in a narrowing ternary): it never + // produces one. + if (LIB_FN_SIGS[e.fn].result.kind !== "void") producedBy(e.type, true); return; case "intrinsic": // Intrinsics hand back values built elsewhere, except allSettled's diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6915-key-order-narrowed-throw.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6915-key-order-narrowed-throw.ts.json new file mode 100644 index 0000000000..83f8cc5d57 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6915-key-order-narrowed-throw.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6915-key-order-narrowed-throw.ts" + ], + "diags": [] +} diff --git a/tests/corpus/6915-key-order-narrowed-throw.ts b/tests/corpus/6915-key-order-narrowed-throw.ts new file mode 100644 index 0000000000..d4bc693f23 --- /dev/null +++ b/tests/corpus/6915-key-order-narrowed-throw.ts @@ -0,0 +1,72 @@ +// A record whose reads narrow a possibly-undefined binding (the narrowing +// ternary's throw arm stands in for a value of the record's type) still +// takes its literal's key order: a module-level accumulator typed by an +// interface declared in another order, as an event batcher builds it. +interface Entry { + id: string; + at: number; + text?: string; + stream: "out" | "err"; +} +interface Batch { + team: string; + project: string; + job: string; + origin: "task" | "worker"; + host: string; + entries: Entry[]; + sizes?: number[]; + stage?: "live" | "staging"; + branch?: string; + run?: string; + entry?: string; + path?: string; +} +interface Job { + id: string; + run?: string; + project: string; + team: string; + host: string; + stage: string | null; +} +let acc: Batch | undefined; + +function append(j: Job, text: string): void { + if (!acc) { + acc = { + run: j.run, + job: j.id, + stage: j.stage === null ? "staging" : "live", + project: j.project, + team: j.team, + origin: "task", + host: j.host, + entry: ".", + entries: [], + }; + } + acc.entries.push({ id: String(acc.entries.length), at: 1, text, stream: "out" }); + setTimeout(() => { + const batch = acc; + if (!batch) return; + acc = undefined; + for (const line of split(batch)) console.log(line); + }, 1); +} + +function split(batch: Batch): string[] { + const json = JSON.stringify(batch); + if (json.length < 200 || batch.entries.length < 2) return [json]; + const index = Math.floor(batch.entries.length / 2); + const first = { ...batch, entries: batch.entries.slice(0, index) }; + const second = { ...batch, entries: batch.entries.slice(index) }; + return [...split(first), ...split(second)]; +} + +const j: Job = { id: "job", run: "r1", project: "prj", team: "core", host: "h", stage: "live" }; +append(j, "one"); +append(j, "two"); +setTimeout(() => { + for (let i = 0; i < 6; i++) append(j, "line " + i); +}, 5); diff --git a/tests/harness/corpus-costs/6915-key-order-narrowed-throw.ts.json b/tests/harness/corpus-costs/6915-key-order-narrowed-throw.ts.json new file mode 100644 index 0000000000..fae2adeb46 --- /dev/null +++ b/tests/harness/corpus-costs/6915-key-order-narrowed-throw.ts.json @@ -0,0 +1 @@ +{ "plain": 1500, "san": 9000 } From 712b4e84a1e52dca58f559a20123f935e68e54c5 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 08:12:12 -0500 Subject: [PATCH 11/23] Support the env option of spawnSync `spawnSync(cmd, args, { env })` replaces the child's environment with the given record, as spawn and execFileSync already do, alone or with the timeout, killSignal and stdio options. The fallback typings declare the option. --- .../ambient/scriptc-node-fallback.d.ts | 4 +- .../compiler/src/backend/llvm/lib-shared.ts | 1 + .../src/backend/llvm/reference-writes.ts | 1 + .../lowering/builtins/child-process.ts | 19 +++++++++- .../compiler/src/ir/builtin-signatures.ts | 6 +++ .../tests/corpus/7030-spawn-sync-env.ts.json | 6 +++ packages/runtime/src/scr_child.c | 38 +++++++++++++++---- packages/runtime/src/scr_child.h | 5 +++ tests/corpus/7030-spawn-sync-env.ts | 28 ++++++++++++++ .../corpus-costs/7030-spawn-sync-env.ts.json | 1 + 10 files changed, 98 insertions(+), 11 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7030-spawn-sync-env.ts.json create mode 100644 tests/corpus/7030-spawn-sync-env.ts create mode 100644 tests/harness/corpus-costs/7030-spawn-sync-env.ts.json diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index 2a3f11be91..c5fce2423f 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -3512,7 +3512,8 @@ declare module "child_process" { * killSignal at the deadline and the result carries error: ETIMEDOUT + * the signal, never a throw), killSignal (a signal NAME literal), * stdio ("ignore"/"inherit"/"pipe" or a 3-tuple of those — captures - * read "" for non-piped streams), and windowsHide (a POSIX no-op). */ + * read "" for non-piped streams), env (replaces the child's + * environment), and windowsHide (a POSIX no-op). */ export function spawnSync( command: string, args?: string[], @@ -3521,6 +3522,7 @@ declare module "child_process" { timeout?: number; killSignal?: string; stdio?: "pipe" | "ignore" | "inherit" | ("pipe" | "ignore" | "inherit")[]; + env?: { [k: string]: string | undefined }; windowsHide?: boolean; }, ): SpawnSyncReturns; diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 9a65d9a242..f18e4a7d52 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -754,6 +754,7 @@ export const LIB_FN_SYMS: Record = { "cp.spawnSync": "scr_spawn_sync", "cp.spawnSyncOpts": "scr_spawn_sync_opts", "cp.spawnSyncStdioStr": "scr_spawn_sync_stdio_str", + "cp.spawnSyncEnv": "scr_spawn_sync_env", "cp.execSync": "scr_exec_sync", "cp.execCapture": "scr_exec_capture", "spawnRes.stdout": "scr_spawn_res_stdout", diff --git a/packages/compiler/src/backend/llvm/reference-writes.ts b/packages/compiler/src/backend/llvm/reference-writes.ts index d31f14d12b..6d1593a55f 100644 --- a/packages/compiler/src/backend/llvm/reference-writes.ts +++ b/packages/compiler/src/backend/llvm/reference-writes.ts @@ -118,6 +118,7 @@ const INERT_LIB_CALLS = new Set([ "worker.parentPort", "worker.root", "cp.spawnSyncOpts", + "cp.spawnSyncEnv", ]); /** jsval conversions (ir/jsval.ts): no user code, no stores. */ diff --git a/packages/compiler/src/frontend/lowering/builtins/child-process.ts b/packages/compiler/src/frontend/lowering/builtins/child-process.ts index ea2dd379d4..9096316a3b 100644 --- a/packages/compiler/src/frontend/lowering/builtins/child-process.ts +++ b/packages/compiler/src/frontend/lowering/builtins/child-process.ts @@ -115,6 +115,8 @@ export function lowerSpawnSyncCall(lowerer: Lowerer, expr: ts.CallExpression, lo // "pipe"`) — accepted when its TYPE proves every arm is a supported // literal; the runtime maps the value to the modes at the call. let stdioStr: IrExpr | null = null; + // The `env` option's [k,v,...] pairs, which replace the child's environment. + let envPairs: IrExpr | null = null; let plain = true; // no behavior-changing option: the historical libCall if (optsNode) { @@ -227,11 +229,16 @@ export function lowerSpawnSyncCall(lowerer: Lowerer, expr: ts.CallExpression, lo case "windowsHide": lowerer.lowerExpr(m.value); // Node no-op on POSIX break; + case "env": + // A REPLACEMENT environment, as for spawn and execFileSync. + envPairs = recordToEnvPairs(lowerer, m.value); + plain = false; + break; default: lowerer.noLowering( `spawnSync option '${m.name}'`, p, - "encoding, timeout, killSignal, stdio, and windowsHide are the supported options", + "encoding, timeout, killSignal, stdio, env, and windowsHide are the supported options", ); } } @@ -239,6 +246,13 @@ export function lowerSpawnSyncCall(lowerer: Lowerer, expr: ts.CallExpression, lo if (plain) { return { kind: "libCall", fn: "cp.spawnSync", args: [cmd, argv], type: SPAWNRES_T, loc }; } + if (stdioStr !== null && envPairs !== null) { + lowerer.noLowering( + "spawnSync with a runtime stdio value and env", + optsNode!, + 'pass stdio as a "pipe"/"ignore"/"inherit" literal when env is set', + ); + } if (stdioStr !== null) { return { kind: "libCall", @@ -250,7 +264,7 @@ export function lowerSpawnSyncCall(lowerer: Lowerer, expr: ts.CallExpression, lo } return { kind: "libCall", - fn: "cp.spawnSyncOpts", + fn: envPairs !== null ? "cp.spawnSyncEnv" : "cp.spawnSyncOpts", args: [ cmd, argv, @@ -259,6 +273,7 @@ export function lowerSpawnSyncCall(lowerer: Lowerer, expr: ts.CallExpression, lo numLit(inMode, loc), numLit(outMode, loc), numLit(errMode, loc), + ...(envPairs !== null ? [envPairs] : []), ], type: SPAWNRES_T, loc, diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index fcdbe86947..6b7dc17414 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -1318,6 +1318,12 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ argTypes: [STRING, arrayOf(STRING), F64, STRING, F64, F64, F64], result: SPAWNRES_T, }, + /** cp.spawnSyncOpts with the `env` option: the trailing [k,v,...] + * pairs replace the child's environment (recordToEnvPairs). */ + "cp.spawnSyncEnv": { + argTypes: [STRING, arrayOf(STRING), F64, STRING, F64, F64, F64, arrayOf(STRING)], + result: SPAWNRES_T, + }, /** cp.spawnSyncOpts with the stdio carried as a RUNTIME string — * "pipe" | "ignore" | "inherit", proven by the call site's TYPE (the * defaultRunner idiom `stdio: options?.stdio ?? "pipe"`); the runtime diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7030-spawn-sync-env.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7030-spawn-sync-env.ts.json new file mode 100644 index 0000000000..f8afbe00ba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7030-spawn-sync-env.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7030-spawn-sync-env.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_child.c b/packages/runtime/src/scr_child.c index ec685656dc..387885c42c 100644 --- a/packages/runtime/src/scr_child.c +++ b/packages/runtime/src/scr_child.c @@ -1105,9 +1105,9 @@ char **scr_child_argv(ScrStr *cmd, ScrArr *args) { static ScrSpawnRes *scr_spawn_sync_core(ScrStr *cmd, ScrArr *args, double timeout_ms, int killsig, int in_mode, int out_mode, - int err_mode) { + int err_mode, ScrArr *env_pairs) { ScrWinSyncRes w; - scr_win_run_sync(cmd, args, NULL, in_mode, out_mode, err_mode, NULL, NULL, + scr_win_run_sync(cmd, args, NULL, in_mode, out_mode, err_mode, NULL, env_pairs, timeout_ms, &w); if (w.spawn_errname != NULL) { free(w.out.data); @@ -1136,19 +1136,26 @@ static ScrSpawnRes *scr_spawn_sync_core(ScrStr *cmd, ScrArr *args, double timeou } ScrSpawnRes *scr_spawn_sync(ScrStr *cmd, ScrArr *args) { - return scr_spawn_sync_core(cmd, args, 0, SIGTERM, 0, 0, 0); + return scr_spawn_sync_core(cmd, args, 0, SIGTERM, 0, 0, 0, NULL); } ScrSpawnRes *scr_spawn_sync_opts(ScrStr *cmd, ScrArr *args, double timeout_ms, ScrStr *killsignal, double in_mode, double out_mode, double err_mode) { + return scr_spawn_sync_env(cmd, args, timeout_ms, killsignal, in_mode, out_mode, err_mode, + NULL); +} + +ScrSpawnRes *scr_spawn_sync_env(ScrStr *cmd, ScrArr *args, double timeout_ms, + ScrStr *killsignal, double in_mode, double out_mode, + double err_mode, ScrArr *env_pairs) { int killsig = SIGTERM; if (killsignal->len > 0) { int resolved = scr_signal_from_name(killsignal); if (resolved > 0) killsig = resolved; } return scr_spawn_sync_core(cmd, args, timeout_ms, killsig, (int)in_mode, - (int)out_mode, (int)err_mode); + (int)out_mode, (int)err_mode, env_pairs); } ScrSpawnRes *scr_spawn_sync_stdio_str(ScrStr *cmd, ScrArr *args, double timeout_ms, @@ -3101,9 +3108,14 @@ static ScrSpawnRes *scr_spawn_res_new(bool has_status, double status, * documented divergence). timeout_ms > 0 sends `killsig` at the deadline * and the result carries error: ETIMEDOUT + the signal — never a throw, * Node's spawnSync shape. */ +static char **scr_exec_envp(ScrArr *pairs); +static void scr_exec_envp_free(char **envp); + +/* env_pairs: NULL inherits the parent's environment; else [k,v,...] + * replaces it, as Node's `env` option does. */ static ScrSpawnRes *scr_spawn_sync_core(ScrStr *cmd, ScrArr *args, double timeout_ms, int killsig, int in_mode, int out_mode, - int err_mode) { + int err_mode, ScrArr *env_pairs) { if (out_mode == 2 || err_mode == 2) { /* Inherited output fds: flush the parent's buffers first so earlier * logs precede the child's writes (Node's practical ordering). */ @@ -3138,10 +3150,13 @@ static ScrSpawnRes *scr_spawn_sync_core(ScrStr *cmd, ScrArr *args, double timeou } char **argv = scr_child_argv(cmd, args); + char **envp = env_pairs != NULL ? scr_exec_envp(env_pairs) : NULL; pid_t pid = -1; - int spawn_err = posix_spawnp(&pid, cmd->data, &fa, NULL, argv, environ); + int spawn_err = posix_spawnp(&pid, cmd->data, &fa, NULL, argv, + envp != NULL ? envp : environ); posix_spawn_file_actions_destroy(&fa); free(argv); + scr_exec_envp_free(envp); if (cap_out) close(outfd[1]); if (cap_err) close(errfd[1]); @@ -3242,7 +3257,7 @@ static ScrSpawnRes *scr_spawn_sync_core(ScrStr *cmd, ScrArr *args, double timeou } ScrSpawnRes *scr_spawn_sync(ScrStr *cmd, ScrArr *args) { - return scr_spawn_sync_core(cmd, args, 0, SIGTERM, 0, 0, 0); + return scr_spawn_sync_core(cmd, args, 0, SIGTERM, 0, 0, 0, NULL); } /* The options entry (cp.spawnSyncOpts): killSignal as a NAME ("" = the @@ -3252,13 +3267,20 @@ ScrSpawnRes *scr_spawn_sync(ScrStr *cmd, ScrArr *args) { ScrSpawnRes *scr_spawn_sync_opts(ScrStr *cmd, ScrArr *args, double timeout_ms, ScrStr *killsignal, double in_mode, double out_mode, double err_mode) { + return scr_spawn_sync_env(cmd, args, timeout_ms, killsignal, in_mode, out_mode, err_mode, + NULL); +} + +ScrSpawnRes *scr_spawn_sync_env(ScrStr *cmd, ScrArr *args, double timeout_ms, + ScrStr *killsignal, double in_mode, double out_mode, + double err_mode, ScrArr *env_pairs) { int killsig = SIGTERM; if (killsignal->len > 0) { int resolved = scr_signal_from_name(killsignal); if (resolved > 0) killsig = resolved; } return scr_spawn_sync_core(cmd, args, timeout_ms, killsig, (int)in_mode, - (int)out_mode, (int)err_mode); + (int)out_mode, (int)err_mode, env_pairs); } /* The runtime-string stdio entry (cp.spawnSyncStdioStr): the compiler diff --git a/packages/runtime/src/scr_child.h b/packages/runtime/src/scr_child.h index e899130d86..a5853ad59d 100644 --- a/packages/runtime/src/scr_child.h +++ b/packages/runtime/src/scr_child.h @@ -23,6 +23,11 @@ ScrSpawnRes *scr_spawn_sync(ScrStr *cmd, ScrArr *args); /* +1, never throws */ ScrSpawnRes *scr_spawn_sync_opts(ScrStr *cmd, ScrArr *args, double timeout_ms, ScrStr *killsignal, double in_mode, double out_mode, double err_mode); +/* scr_spawn_sync_opts with an `env` option: [k,v,...] pairs replace the + * child's environment (NULL inherits the parent's). */ +ScrSpawnRes *scr_spawn_sync_env(ScrStr *cmd, ScrArr *args, double timeout_ms, + ScrStr *killsignal, double in_mode, double out_mode, + double err_mode, ScrArr *env_pairs); /* The runtime-string stdio entry: the compiler proved the value is * "pipe" | "ignore" | "inherit" by type; the mode mapping happens here. */ ScrSpawnRes *scr_spawn_sync_stdio_str(ScrStr *cmd, ScrArr *args, double timeout_ms, diff --git a/tests/corpus/7030-spawn-sync-env.ts b/tests/corpus/7030-spawn-sync-env.ts new file mode 100644 index 0000000000..e613c81f09 --- /dev/null +++ b/tests/corpus/7030-spawn-sync-env.ts @@ -0,0 +1,28 @@ +// spawnSync's env option replaces the child's environment, alone or with +// the other options. +import { spawnSync } from "node:child_process"; + +const merged = spawnSync("sh", ["-c", 'echo "$GREETING $HOME_SET"'], { + env: { ...process.env, GREETING: "hello", HOME_SET: process.env.HOME ? "yes" : "no" }, + encoding: "utf8", +}); +console.log(merged.stdout.trim(), merged.status); + +const only = spawnSync("/bin/sh", ["-c", 'echo "${GREETING:-unset} ${HOME:-nohome}"'], { + env: { GREETING: "only" }, + encoding: "utf8", +}); +console.log(only.stdout.trim()); + +const empty = spawnSync("/bin/sh", ["-c", "env | grep -c ."], { env: {}, encoding: "utf8" }); +console.log(Number(empty.stdout.trim()) <= 3, empty.status); + +const quiet = spawnSync("sh", ["-c", 'echo "$MODE" >&2; exit 4'], { + env: { PATH: process.env.PATH ?? "/usr/bin:/bin", MODE: "loud" }, + stdio: ["ignore", "pipe", "pipe"], + timeout: 5000, +}); +console.log(quiet.status, quiet.stderr.toString().trim(), quiet.stdout.toString() === ""); + +const missing = spawnSync("/nonexistent/tool", [], { env: { A: "1" } }); +console.log(missing.status, missing.error?.message); diff --git a/tests/harness/corpus-costs/7030-spawn-sync-env.ts.json b/tests/harness/corpus-costs/7030-spawn-sync-env.ts.json new file mode 100644 index 0000000000..cf8ef4d26e --- /dev/null +++ b/tests/harness/corpus-costs/7030-spawn-sync-env.ts.json @@ -0,0 +1 @@ +{ "plain": 2460, "san": 4060 } From c9ae4d80196eeabdacc7574f3dd216bf0422f32e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 09:55:30 -0500 Subject: [PATCH 12/23] Look up spawnSync commands on the replacement environment's PATH With an `env` option, spawnSync searched the parent's PATH for a command without a '/'. Node (libuv) searches the PATH of the child's environment, or the default path when that environment has none, so a command only on the child's PATH ran as ENOENT and one only on the parent's PATH ran where Node reports ENOENT. The lookup now follows libuv: each PATH entry in order, an empty entry as the current directory, and EACCES when a candidate exists but cannot run. --- packages/runtime/src/scr_child.c | 62 +++++++++++++++++++++++++++-- tests/corpus/7030-spawn-sync-env.ts | 19 +++++++++ 2 files changed, 78 insertions(+), 3 deletions(-) diff --git a/packages/runtime/src/scr_child.c b/packages/runtime/src/scr_child.c index 387885c42c..df60fcb26c 100644 --- a/packages/runtime/src/scr_child.c +++ b/packages/runtime/src/scr_child.c @@ -2907,6 +2907,7 @@ void scr_children_poll(void) { #include #include #include +#include #include #include #include @@ -3111,8 +3112,55 @@ static ScrSpawnRes *scr_spawn_res_new(bool has_status, double status, static char **scr_exec_envp(ScrArr *pairs); static void scr_exec_envp_free(char **envp); +/* The executable `file` names when `envp` replaces the child's + * environment, found as libuv finds it: a name with a '/' is used as + * given; otherwise each entry of the replacement's PATH (an empty entry + * is the current directory), or of the default path when the replacement + * has no PATH, is tried in order. Returns a malloc'd path, or NULL with + * *err set: EACCES when a candidate exists but cannot run, else ENOENT. */ +static char *scr_spawn_path_lookup(const char *file, char *const *envp, int *err) { + if (strchr(file, '/')) { + char *copy = strdup(file); + if (!copy) scr_child_oom(); + return copy; + } + const char *path = "/usr/bin:/bin"; + for (char *const *e = envp; *e; e++) { + if (strncmp(*e, "PATH=", 5) == 0) { + path = *e + 5; + break; + } + } + size_t file_len = strlen(file); + bool denied = false; + for (const char *dir = path;;) { + const char *end = strchr(dir, ':'); + size_t dir_len = end ? (size_t)(end - dir) : strlen(dir); + const char *prefix = dir_len ? dir : "."; + size_t prefix_len = dir_len ? dir_len : 1; + char *candidate = malloc(prefix_len + 1 + file_len + 1); + if (!candidate) scr_child_oom(); + memcpy(candidate, prefix, prefix_len); + candidate[prefix_len] = '/'; + memcpy(candidate + prefix_len + 1, file, file_len + 1); + struct stat st; + if (stat(candidate, &st) == 0) { + if (S_ISREG(st.st_mode) && access(candidate, X_OK) == 0) return candidate; + denied = true; + } else if (errno == EACCES) { + denied = true; + } + free(candidate); + if (!end) break; + dir = end + 1; + } + *err = denied ? EACCES : ENOENT; + return NULL; +} + /* env_pairs: NULL inherits the parent's environment; else [k,v,...] - * replaces it, as Node's `env` option does. */ + * replaces it, as Node's `env` option does, and the command is looked up + * on the replacement's PATH (scr_spawn_path_lookup). */ static ScrSpawnRes *scr_spawn_sync_core(ScrStr *cmd, ScrArr *args, double timeout_ms, int killsig, int in_mode, int out_mode, int err_mode, ScrArr *env_pairs) { @@ -3152,8 +3200,16 @@ static ScrSpawnRes *scr_spawn_sync_core(ScrStr *cmd, ScrArr *args, double timeou char **argv = scr_child_argv(cmd, args); char **envp = env_pairs != NULL ? scr_exec_envp(env_pairs) : NULL; pid_t pid = -1; - int spawn_err = posix_spawnp(&pid, cmd->data, &fa, NULL, argv, - envp != NULL ? envp : environ); + int spawn_err; + if (envp != NULL) { + char *resolved = scr_spawn_path_lookup(cmd->data, envp, &spawn_err); + if (resolved) { + spawn_err = posix_spawn(&pid, resolved, &fa, NULL, argv, envp); + free(resolved); + } + } else { + spawn_err = posix_spawnp(&pid, cmd->data, &fa, NULL, argv, environ); + } posix_spawn_file_actions_destroy(&fa); free(argv); scr_exec_envp_free(envp); diff --git a/tests/corpus/7030-spawn-sync-env.ts b/tests/corpus/7030-spawn-sync-env.ts index e613c81f09..0ab001b8fb 100644 --- a/tests/corpus/7030-spawn-sync-env.ts +++ b/tests/corpus/7030-spawn-sync-env.ts @@ -1,6 +1,9 @@ // spawnSync's env option replaces the child's environment, alone or with // the other options. import { spawnSync } from "node:child_process"; +import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; const merged = spawnSync("sh", ["-c", 'echo "$GREETING $HOME_SET"'], { env: { ...process.env, GREETING: "hello", HOME_SET: process.env.HOME ? "yes" : "no" }, @@ -26,3 +29,19 @@ console.log(quiet.status, quiet.stderr.toString().trim(), quiet.stdout.toString( const missing = spawnSync("/nonexistent/tool", [], { env: { A: "1" } }); console.log(missing.status, missing.error?.message); + +// The command is found on the replacement environment's PATH, or on the +// default path when the replacement has none, not on the parent's PATH. +const dir = mkdtempSync(join(tmpdir(), "scr-spawn-path-")); +writeFileSync(join(dir, "child-only-tool"), "#!/bin/sh\necho child-only\n"); +chmodSync(join(dir, "child-only-tool"), 0o755); +writeFileSync(join(dir, "not-executable"), "#!/bin/sh\necho never\n"); +const viaPath = spawnSync("child-only-tool", [], { env: { PATH: `/nonexistent:${dir}` }, encoding: "utf8" }); +console.log(viaPath.status, viaPath.stdout.trim()); +const defaultPath = spawnSync("sh", ["-c", "echo default"], { env: { A: "1" }, encoding: "utf8" }); +console.log(defaultPath.status, defaultPath.stdout.trim()); +const notOnPath = spawnSync("sh", ["-c", "echo never"], { env: { PATH: dir }, encoding: "utf8" }); +console.log(notOnPath.status, notOnPath.error?.message); +const denied = spawnSync("not-executable", [], { env: { PATH: dir }, encoding: "utf8" }); +console.log(denied.status, denied.error?.message); +rmSync(dir, { recursive: true }); From c43d4002e71f3c87a8b7bee79c12c02793bf1c2b Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 09:59:57 -0500 Subject: [PATCH 13/23] Skip only always-throwing calls as record producers in the key-order witness The witness skipped every libCall whose signature result is VOID. VOID is also the signature of runtime calls that take their record type from the use site and build the record at run time, such as net.serverAddress (`server.address()`). A literal of the same shape then set the shape's key order, and the runtime record enumerated in the literal's order instead of Node's (`port, family, address` for `address, family, port`). The witness now skips only the calls in ALWAYS_THROW_LIB_FNS, which never produce a value. The set moves from validate.ts's result-type check to builtin-effects.ts, and both use it. --- .../lowering/key-order-witness.test.ts | 30 +++++++++++++++++++ .../frontend/lowering/key-order-witness.ts | 11 +++---- packages/compiler/src/ir/builtin-effects.ts | 22 ++++++++++++++ packages/compiler/src/ir/validate.ts | 29 ++---------------- 4 files changed, 61 insertions(+), 31 deletions(-) diff --git a/packages/compiler/src/frontend/lowering/key-order-witness.test.ts b/packages/compiler/src/frontend/lowering/key-order-witness.test.ts index de16e5d611..8632bad47c 100644 --- a/packages/compiler/src/frontend/lowering/key-order-witness.test.ts +++ b/packages/compiler/src/frontend/lowering/key-order-witness.test.ts @@ -157,6 +157,36 @@ test("a synthesized construction pins today's table", () => { expect(f.order(ab)).toEqual(["a", "b"]); }); +test("a runtime builder typed by its use site pins today's table", () => { + const f = fixture(); + const ab = f.record( + [ + ["a", F64], + ["b", F64], + ], + ["a", "b"], + ); + // net.serverAddress's signature result is VOID: the call takes its record + // type from its use site, and the runtime builds the record in that order. + const built: IrExpr = { kind: "libCall", fn: "net.serverAddress", args: [], type: ab, loc }; + f.run([observe(f.literal(ab, ["b", "a"])), observe(built)]); + expect(f.order(ab)).toEqual(["a", "b"]); +}); + +test("an always-throwing call typed as the record leaves its literals' order", () => { + const f = fixture(); + const ab = f.record( + [ + ["a", F64], + ["b", F64], + ], + ["a", "b"], + ); + const thrown: IrExpr = { kind: "libCall", fn: "error.nodeThrow", args: [], type: ab, loc }; + f.run([observe(f.literal(ab, ["b", "a"])), observe(thrown)]); + expect(f.order(ab)).toEqual(["b", "a"]); +}); + test("a checked conversion alone pins today's table", () => { const f = fixture(); const ab = f.record( diff --git a/packages/compiler/src/frontend/lowering/key-order-witness.ts b/packages/compiler/src/frontend/lowering/key-order-witness.ts index 7ce8ae074a..4adfb87ab2 100644 --- a/packages/compiler/src/frontend/lowering/key-order-witness.ts +++ b/packages/compiler/src/frontend/lowering/key-order-witness.ts @@ -45,7 +45,7 @@ import type { IrExpr, IrFunction, IrRecordShape, IrStmt, IrType } from "../../ir import { shapeHasAccessorSlots, typeEquals, UNDEFINED_T } from "../../ir/ir.js"; import { everyExprChild, everyStmtChild, everyTypeChild } from "../../ir/traverse.js"; import type { Lowerer } from "./lowerer.js"; -import { LIB_FN_SIGS } from "../../ir/builtin-signatures.js"; +import { ALWAYS_THROW_LIB_FNS } from "../../ir/builtin-effects.js"; /** One property of an object literal, in source order. */ export type KeyOrderSegment = @@ -313,10 +313,11 @@ export function applyKeyOrderWitnesses(lowerer: Lowerer, fns: readonly IrFunctio // Runtime surfaces (console, util.format, workers) that take a // record may walk its keys; runtime builders make new records. for (const arg of e.args) observedRoots.push(arg.type); - // A void runtime call typed by its use site is a throw standing in - // for a value (`error.nodeThrow` in a narrowing ternary): it never - // produces one. - if (LIB_FN_SIGS[e.fn].result.kind !== "void") producedBy(e.type, true); + // An always-throwing call stands in for a value (`error.nodeThrow` + // in a narrowing ternary) and never produces one. Other calls + // whose signature result is VOID are typed by their use site and + // build the record at run time (`server.address()`). + if (!ALWAYS_THROW_LIB_FNS.has(e.fn)) producedBy(e.type, true); return; case "intrinsic": // Intrinsics hand back values built elsewhere, except allSettled's diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index 16db45b6c5..c2194a13c4 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -1001,3 +1001,25 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ "crypto.createSign", "crypto.createVerify", ]); + +/** libCall members that always throw. Their result type is the replaced + * expression's own and is never materialized: global.undefRead's is the + * declared type of the undefined global; the others stand in for a value + * of the expression they replace. The fs Chk ladders qualify: every + * validation failure throws Node's typed error, and a full pass throws the + * trailing compiler-rendered fence. */ +export const ALWAYS_THROW_LIB_FNS: ReadonlySet = new Set([ + "global.undefRead", + "error.nodeThrow", + "error.argTypeThrow", + "error.propTypeThrow", + "fs.mkdtempChk", + "fs.readFileChk", + "fs.opendirChk", + "fs.watchFileChk", + "fs.lchmodChk", + "fs.readChk", + "fs.streamOptsChk", + "net.connectOptsChk", + "tls.caCertsChk", +]); diff --git a/packages/compiler/src/ir/validate.ts b/packages/compiler/src/ir/validate.ts index bb36c70074..163c2a41c4 100644 --- a/packages/compiler/src/ir/validate.ts +++ b/packages/compiler/src/ir/validate.ts @@ -61,6 +61,7 @@ import { unionWideningTags } from "./analysis.js"; import { alwaysReturns } from "./control-flow.js"; import { dynamicOperationOf, functionTier } from "./tiers.js"; import { LIB_FN_SIGS, pipelinePumpedRuns } from "./builtin-signatures.js"; +import { ALWAYS_THROW_LIB_FNS } from "./builtin-effects.js"; /** The promisified crypto calls' value kinds besides checked-dynamic. */ const CRYPTO_PROMISE_VALUES: Readonly> = { @@ -5345,32 +5346,8 @@ function validateFunction( const callback = e.args[e.args.length - 1]?.type; if (callback?.kind !== "func") err(`libCall ${e.fn} callback must be a function`, e.loc); } - if (e.fn === "global.undefRead") { - // Always throws — the result type is whatever the declared type - // of the undefined global mapped to (never materialized). - return true; - } - if ( - e.fn === "error.nodeThrow" || - e.fn === "error.argTypeThrow" || - e.fn === "error.propTypeThrow" || - e.fn === "fs.mkdtempChk" || - e.fn === "fs.readFileChk" || - e.fn === "fs.opendirChk" || - e.fn === "fs.watchFileChk" || - e.fn === "fs.lchmodChk" || - e.fn === "fs.readChk" || - e.fn === "fs.streamOptsChk" || - e.fn === "net.connectOptsChk" || - e.fn === "tls.caCertsChk" - ) { - // Always throws — the result type is the replaced expression's - // own (never materialized; the global.undefRead pattern). The - // fs Chk ladders qualify: every validation failure throws - // Node's typed error, and a full pass throws the trailing - // compiler-rendered fence. - return true; - } + // Always throws: the result type is never materialized. + if (ALWAYS_THROW_LIB_FNS.has(e.fn)) return true; if (e.fn === "error.new" || e.fn === "error.newOptions") { // Which builtin the runtime constructs is named by the result type. if (!isBuiltinErrorObject(e.type)) { From 3a3610d12ebfaedce85f3e877338500da9e7f8dc Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 10:15:10 -0500 Subject: [PATCH 14/23] Look up spawn and execFileSync commands on the replacement environment's PATH spawn and execFileSync with an `env` option searched the parent's PATH for a command without a '/'. They now resolve it the way spawnSync does, as Node (libuv) does: on the replacement environment's PATH, or the default path when it has none, with relative entries read from the cwd option's directory. --- .../corpus/7036-child-env-path-lookup.ts.json | 6 ++ packages/runtime/src/scr_child.c | 62 +++++++++++++------ tests/corpus/7036-child-env-path-lookup.ts | 40 ++++++++++++ .../7036-child-env-path-lookup.ts.json | 1 + 4 files changed, 89 insertions(+), 20 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7036-child-env-path-lookup.ts.json create mode 100644 tests/corpus/7036-child-env-path-lookup.ts create mode 100644 tests/harness/corpus-costs/7036-child-env-path-lookup.ts.json diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7036-child-env-path-lookup.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7036-child-env-path-lookup.ts.json new file mode 100644 index 0000000000..171ab060a5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7036-child-env-path-lookup.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7036-child-env-path-lookup.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_child.c b/packages/runtime/src/scr_child.c index df60fcb26c..c1d98b35b5 100644 --- a/packages/runtime/src/scr_child.c +++ b/packages/runtime/src/scr_child.c @@ -3116,9 +3116,12 @@ static void scr_exec_envp_free(char **envp); * environment, found as libuv finds it: a name with a '/' is used as * given; otherwise each entry of the replacement's PATH (an empty entry * is the current directory), or of the default path when the replacement - * has no PATH, is tried in order. Returns a malloc'd path, or NULL with - * *err set: EACCES when a candidate exists but cannot run, else ENOENT. */ -static char *scr_spawn_path_lookup(const char *file, char *const *envp, int *err) { + * has no PATH, is tried in order. Relative candidates are checked from + * `cwd`, the directory the child starts in (NULL: this process's). Returns + * a malloc'd path, or NULL with *err set: EACCES when a candidate exists + * but cannot run, else ENOENT. */ +static char *scr_spawn_path_lookup(const char *file, char *const *envp, const char *cwd, + int *err) { if (strchr(file, '/')) { char *copy = strdup(file); if (!copy) scr_child_oom(); @@ -3132,6 +3135,7 @@ static char *scr_spawn_path_lookup(const char *file, char *const *envp, int *err } } size_t file_len = strlen(file); + size_t cwd_len = cwd ? strlen(cwd) : 0; bool denied = false; for (const char *dir = path;;) { const char *end = strchr(dir, ':'); @@ -3143,13 +3147,24 @@ static char *scr_spawn_path_lookup(const char *file, char *const *envp, int *err memcpy(candidate, prefix, prefix_len); candidate[prefix_len] = '/'; memcpy(candidate + prefix_len + 1, file, file_len + 1); + char *checked = candidate; + if (cwd_len > 0 && candidate[0] != '/') { + checked = malloc(cwd_len + 1 + strlen(candidate) + 1); + if (!checked) scr_child_oom(); + memcpy(checked, cwd, cwd_len); + checked[cwd_len] = '/'; + strcpy(checked + cwd_len + 1, candidate); + } struct stat st; - if (stat(candidate, &st) == 0) { - if (S_ISREG(st.st_mode) && access(candidate, X_OK) == 0) return candidate; - denied = true; + bool runs = false; + if (stat(checked, &st) == 0) { + runs = S_ISREG(st.st_mode) && access(checked, X_OK) == 0; + if (!runs) denied = true; } else if (errno == EACCES) { denied = true; } + if (checked != candidate) free(checked); + if (runs) return candidate; free(candidate); if (!end) break; dir = end + 1; @@ -3158,6 +3173,22 @@ static char *scr_spawn_path_lookup(const char *file, char *const *envp, int *err return NULL; } +/* posix_spawnp for the child_process spawns: with `envp` (a replacement + * environment) the command resolves on that environment's PATH + * (scr_spawn_path_lookup) as Node's does; without it, on this process's + * PATH over `environ`. Returns posix_spawn's error number. */ +static int scr_spawn_command(pid_t *pid, const char *file, const posix_spawn_file_actions_t *fa, + const posix_spawnattr_t *attr, char *const *argv, + char *const *envp, const char *cwd) { + if (envp == NULL) return posix_spawnp(pid, file, fa, attr, argv, environ); + int err = 0; + char *resolved = scr_spawn_path_lookup(file, envp, cwd, &err); + if (!resolved) return err; + err = posix_spawn(pid, resolved, fa, attr, argv, envp); + free(resolved); + return err; +} + /* env_pairs: NULL inherits the parent's environment; else [k,v,...] * replaces it, as Node's `env` option does, and the command is looked up * on the replacement's PATH (scr_spawn_path_lookup). */ @@ -3200,16 +3231,7 @@ static ScrSpawnRes *scr_spawn_sync_core(ScrStr *cmd, ScrArr *args, double timeou char **argv = scr_child_argv(cmd, args); char **envp = env_pairs != NULL ? scr_exec_envp(env_pairs) : NULL; pid_t pid = -1; - int spawn_err; - if (envp != NULL) { - char *resolved = scr_spawn_path_lookup(cmd->data, envp, &spawn_err); - if (resolved) { - spawn_err = posix_spawn(&pid, resolved, &fa, NULL, argv, envp); - free(resolved); - } - } else { - spawn_err = posix_spawnp(&pid, cmd->data, &fa, NULL, argv, environ); - } + int spawn_err = scr_spawn_command(&pid, cmd->data, &fa, NULL, argv, envp, NULL); posix_spawn_file_actions_destroy(&fa); free(argv); scr_exec_envp_free(envp); @@ -3556,8 +3578,8 @@ ScrStr *scr_exec_sync_core(ScrStr *cmd, ScrArr *args, const ScrExecOpts *o) { char **argv = scr_child_argv(cmd, args); char **envp = o->env_pairs != NULL ? scr_exec_envp(o->env_pairs) : NULL; pid_t pid = -1; - int spawn_err = posix_spawnp(&pid, cmd->data, &fa, NULL, argv, - envp != NULL ? envp : environ); + int spawn_err = scr_spawn_command(&pid, cmd->data, &fa, NULL, argv, envp, + o->cwd != NULL ? o->cwd->data : NULL); posix_spawn_file_actions_destroy(&fa); free(argv); scr_exec_envp_free(envp); @@ -5115,8 +5137,8 @@ ScrChild *scr_spawn_opts(ScrStr *cmd, ScrArr *args, double in_mode, char **envp = has_env && env_pairs != NULL ? scr_exec_envp(env_pairs) : NULL; pid_t pid = -1; const char *file = shell ? "/bin/sh" : cmd->data; - int spawn_err = posix_spawnp(&pid, file, &fa, &at, argv, - envp != NULL ? envp : environ); + int spawn_err = scr_spawn_command(&pid, file, &fa, &at, argv, envp, + cwd != NULL && cwd->len > 0 ? cwd->data : NULL); posix_spawnattr_destroy(&at); posix_spawn_file_actions_destroy(&fa); if (!shell) free(argv); diff --git a/tests/corpus/7036-child-env-path-lookup.ts b/tests/corpus/7036-child-env-path-lookup.ts new file mode 100644 index 0000000000..cac0670e9d --- /dev/null +++ b/tests/corpus/7036-child-env-path-lookup.ts @@ -0,0 +1,40 @@ +// spawn and execFileSync with an env option find the command on the +// replacement environment's PATH, or on the default path when it has +// none, as Node does; a relative PATH entry is read from the cwd option. +import { execFileSync, spawn } from "node:child_process"; +import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; + +const dir = mkdtempSync(join(tmpdir(), "scr-child-path-")); +mkdirSync(join(dir, "tools")); +writeFileSync(join(dir, "tools", "child-tool"), "#!/bin/sh\necho child-tool $1\n"); +chmodSync(join(dir, "tools", "child-tool"), 0o755); + +const show = (e: unknown): string => { + const err = e as NodeJS.ErrnoException; + return `${err.code} ${err.message.replace(dir, "")}`; +}; + +console.log(execFileSync("child-tool", ["sync"], { env: { PATH: join(dir, "tools") }, encoding: "utf8" }).trim()); +console.log(execFileSync("sh", ["-c", "echo default"], { env: { A: "1" }, encoding: "utf8" }).trim()); +try { + execFileSync("sh", ["-c", "echo never"], { env: { PATH: "/nonexistent" }, encoding: "utf8" }); +} catch (e) { + console.log(show(e)); +} +console.log( + execFileSync("child-tool", ["relative"], { env: { PATH: "tools" }, cwd: dir, encoding: "utf8" }).trim(), +); + +const child = spawn("child-tool", ["async"], { env: { PATH: join(dir, "tools") }, stdio: ["ignore", "pipe", "ignore"] }); +let out = ""; +child.stdout!.on("data", (chunk: Buffer) => (out += chunk.toString())); +child.on("close", (code) => { + console.log(out.trim(), code); + const missing = spawn("sh", ["-c", "true"], { env: { PATH: "/nonexistent" }, stdio: "ignore" }); + missing.on("error", (e) => { + console.log("error", show(e)); + rmSync(dir, { recursive: true }); + }); +}); diff --git a/tests/harness/corpus-costs/7036-child-env-path-lookup.ts.json b/tests/harness/corpus-costs/7036-child-env-path-lookup.ts.json new file mode 100644 index 0000000000..f9bfce7d9f --- /dev/null +++ b/tests/harness/corpus-costs/7036-child-env-path-lookup.ts.json @@ -0,0 +1 @@ +{ "plain": 2570, "san": 4110 } From ccfca67aecc819a66e38baafe01e213f99f1337f Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 10:30:56 -0500 Subject: [PATCH 15/23] Fix chalk builder field calls and hot-shots send failures and tcp completion --- packages/compiler/shims/hot-shots/client.ts | 23 ++++++++++--- .../src/frontend/lowering/lower-calls.ts | 4 +++ .../npm/cases/chalk5-builder/main.ts.json | 1 + .../fixtures/npm/cases/chalk5/main.ts.json | 1 + .../npm/cases/hot-shots-buffered/main.ts.json | 2 ++ .../cases/hot-shots-send-error/main.ts.json | 8 +++++ .../npm/cases/hot-shots-tcp/main.ts.json | 8 +++++ .../npm/cases/hot-shots-udp/main.ts.json | 2 ++ packages/runtime/src/scr_dgram.h | 7 ++++ .../fixtures/npm/cases/chalk5-builder/main.ts | 5 ++- .../npm/cases/hot-shots-send-error/main.ts | 27 +++++++++++++++ .../cases/hot-shots-send-error/package.json | 1 + .../fixtures/npm/cases/hot-shots-tcp/main.ts | 33 +++++++++++++++++++ .../npm/cases/hot-shots-tcp/package.json | 1 + 14 files changed, 118 insertions(+), 5 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-send-error/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-tcp/main.ts.json create mode 100644 tests/fixtures/npm/cases/hot-shots-send-error/main.ts create mode 100644 tests/fixtures/npm/cases/hot-shots-send-error/package.json create mode 100644 tests/fixtures/npm/cases/hot-shots-tcp/main.ts create mode 100644 tests/fixtures/npm/cases/hot-shots-tcp/package.json diff --git a/packages/compiler/shims/hot-shots/client.ts b/packages/compiler/shims/hot-shots/client.ts index b407132f47..354744e7b5 100644 --- a/packages/compiler/shims/hot-shots/client.ts +++ b/packages/compiler/shims/hot-shots/client.ts @@ -179,6 +179,8 @@ interface Transport { close(): void; onError(listener: (err: Error) => void): void; offError(listener: (err: Error) => void): void; + /** Emits 'error' on the socket, as hot-shots' `socket.emit('error')`. */ + emitError(err: Error): void; onClose(listener: () => void): void; } @@ -261,6 +263,9 @@ class UdpTransport implements Transport { offError(listener: (err: Error) => void): void { this.errors.remove(listener); } + emitError(err: Error): void { + this.errors.emit(err); + } onClose(listener: () => void): void { this.socket.on("close", listener); } @@ -281,10 +286,10 @@ class TcpTransport implements Transport { this.socket.on("error", (err) => errors.emit(err)); } send(buf: Buffer, callback: SendCallback): void { - // The typed socket's write takes the data alone; the completion runs - // on the next tick. - this.socket.write(addEol(buf)); - process.nextTick(() => callback(null)); + // hot-shots writes the line with the 'ascii' encoding, which encodes + // strings as 'latin1' does. The callback runs once the data is written, + // so a message held back by a full socket buffer stays in flight. + this.socket.write(Buffer.from(addEol(buf), "latin1"), (err) => callback(err ?? null)); } close(): void { this.socket.destroy(); @@ -295,6 +300,9 @@ class TcpTransport implements Transport { offError(listener: (err: Error) => void): void { this.errors.remove(listener); } + emitError(err: Error): void { + this.errors.emit(err); + } onClose(listener: () => void): void { this.socket.on("close", () => listener()); } @@ -376,6 +384,9 @@ class UdsTransport implements Transport { offError(listener: (err: Error) => void): void { this.errors.remove(listener); } + emitError(err: Error): void { + this.errors.emit(err); + } onClose(listener: () => void): void { this.closeListeners.push(listener); } @@ -999,6 +1010,10 @@ export class StatsD { handler(errFormatted); } else { console.error(String(errFormatted)); + // hot-shots also emits the error on the current socket, where the + // uds reconnection handler listens; with no listener it throws. + const current = this.transport; + if (current !== null) current.emitError(errFormatted); } } }; diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index b650ca5672..301670c3a3 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -9250,6 +9250,10 @@ export function lowerRecordFieldCall( if (callee.type.kind === "object" && !init) { const direct = callableInstanceStringCall(lowerer, call, callee, loc); if (direct) return direct; + // Other argument counts call the %call closure through its value, as + // a call on the builder itself does (`theme.error("a", "b")`). + const closure = lowerer.hybridCallUnwrap(callee); + if (closure !== callee) return lowerCallThroughValue(lowerer, call, closure, loc); } if (callee.type.kind === "record" || callee.type.kind === "object") callee = lowerer.hybridCallUnwrap(callee); diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5-builder/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5-builder/main.ts.json index 545c4d701c..8f7268daf9 100644 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5-builder/main.ts.json +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5-builder/main.ts.json @@ -1,5 +1,6 @@ { "order": [ + "/packages/compiler/shims/chalk/v5.ts", "/tests/fixtures/npm/cases/chalk5-builder/main.ts" ], "diags": [] diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json index 065c963470..8365d4db93 100644 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chalk5/main.ts.json @@ -1,5 +1,6 @@ { "order": [ + "/packages/compiler/shims/chalk/v5.ts", "/tests/fixtures/npm/cases/chalk5/main.ts" ], "diags": [] diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-buffered/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-buffered/main.ts.json index e60660c09a..a48e1af781 100644 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-buffered/main.ts.json +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-buffered/main.ts.json @@ -1,5 +1,7 @@ { "order": [ + "/packages/compiler/shims/hot-shots/client.ts", + "/packages/compiler/shims/hot-shots/v8.ts", "/tests/fixtures/npm/cases/hot-shots-buffered/main.ts" ], "diags": [] diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-send-error/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-send-error/main.ts.json new file mode 100644 index 0000000000..716cfe02fe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-send-error/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/packages/compiler/shims/hot-shots/client.ts", + "/packages/compiler/shims/hot-shots/v8.ts", + "/tests/fixtures/npm/cases/hot-shots-send-error/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-tcp/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-tcp/main.ts.json new file mode 100644 index 0000000000..f131361e8d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-tcp/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/packages/compiler/shims/hot-shots/client.ts", + "/packages/compiler/shims/hot-shots/v8.ts", + "/tests/fixtures/npm/cases/hot-shots-tcp/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-udp/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-udp/main.ts.json index 54baff8907..a3014fb9f0 100644 --- a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-udp/main.ts.json +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hot-shots-udp/main.ts.json @@ -1,5 +1,7 @@ { "order": [ + "/packages/compiler/shims/hot-shots/client.ts", + "/packages/compiler/shims/hot-shots/v8.ts", "/tests/fixtures/npm/cases/hot-shots-udp/main.ts" ], "diags": [] diff --git a/packages/runtime/src/scr_dgram.h b/packages/runtime/src/scr_dgram.h index 8396f06937..08db077df2 100644 --- a/packages/runtime/src/scr_dgram.h +++ b/packages/runtime/src/scr_dgram.h @@ -55,6 +55,13 @@ double scr_dgram_addr_port(ScrDgramSocket *s); void scr_dgram_close(ScrDgramSocket *s, ScrClosure *cb /*moves, nullable*/); /* throws on closed */ void scr_dgram_unref(ScrDgramSocket *s); void scr_dgram_ref(ScrDgramSocket *s); +/* Unix datagram sockets for the hot-shots package shim (the unix-dgram + * addon's surface): each answers its result (fd, 0) or a negative errno; + * send answers 1 when the socket would block. */ +double scr_dgram_unix_socket(void); +double scr_dgram_unix_connect(double fd, ScrStr *path /*borrowed*/); +double scr_dgram_unix_send(double fd, ScrBytes *data /*borrowed*/); +double scr_dgram_unix_close(double fd); /* Socket options: Node's checks and errors (ErrnoException " * ", ERR_SOCKET_BAD_BUFFER_SIZE, ERR_SOCKET_BUFFER_SIZE, the * TypeError after close()). The TTL setters and setMulticastLoopback diff --git a/tests/fixtures/npm/cases/chalk5-builder/main.ts b/tests/fixtures/npm/cases/chalk5-builder/main.ts index 8f26237179..2a4fff61be 100644 --- a/tests/fixtures/npm/cases/chalk5-builder/main.ts +++ b/tests/fixtures/npm/cases/chalk5-builder/main.ts @@ -1,6 +1,7 @@ // chalk 5 builders used as values (the package compiles from scriptc's // built-in shim): builders in function slots and arrays, styles picked at -// run time, visible at level 0, chalkStderr, and the root's own call. +// run time, builders in record fields called with any number of arguments, +// visible at level 0, chalkStderr, and the root's own call. import chalk, { Chalk, chalkStderr, type ChalkInstance, type ForegroundColorName } from "chalk"; const show = (label: string, value: string): void => { @@ -36,6 +37,8 @@ const off = new Chalk({ level: 0 }); show("visible off", off.visible("v") + "|" + off.red.visible("v") + "|" + off.red("plain")); show("root call", c("a", 1, true) + "|" + c() + "|" + c(undefined) + "|" + c(null, "n")); show("builder args", c.red(undefined) + "|" + c.red(null) + "|" + c.red(1, 2) + "|" + c.red()); +const theme = { error: c.red, note: c.bold.blue }; +show("field args", theme.error("a", "b") + "|" + theme.note("x", 1, true) + "|" + theme.error("one") + "|" + theme.error()); show("multiline", c.cyan("one\r\ntwo\nthree")); show("stderr level", String(chalkStderr.level >= 0)); show("rgb levels", [1, 2, 3].map((level) => new Chalk({ level: level as 1 | 2 | 3 }).rgb(255, 136, 0)("o")).join("|")); diff --git a/tests/fixtures/npm/cases/hot-shots-send-error/main.ts b/tests/fixtures/npm/cases/hot-shots-send-error/main.ts new file mode 100644 index 0000000000..e829c5e333 --- /dev/null +++ b/tests/fixtures/npm/cases/hot-shots-send-error/main.ts @@ -0,0 +1,27 @@ +// The hot-shots StatsD client (compiled from scriptc's built-in shim) when a +// send fails: with a callback or an errorHandler the error goes there; with +// neither, the client logs it and emits it on the socket, where an 'error' +// event nobody listens for ends the process with status 1. +import { StatsD } from "hot-shots"; + +// A datagram larger than udp allows fails with EMSGSIZE before it leaves +// the host; port 9 keeps the message the same on every run. +const big = "x".repeat(70000); + +const withCallback = new StatsD({ host: "127.0.0.1", port: 9 }); +withCallback.increment(big, 1, 1, [], (err: Error | null | undefined) => { + console.log("callback:", err ? err.message : "no error"); + withCallback.close(); + + const withHandler = new StatsD({ + host: "127.0.0.1", + port: 9, + errorHandler: (error: Error) => { + console.log("errorHandler:", error.message); + withHandler.close(); + console.log("without a callback or errorHandler"); + new StatsD({ host: "127.0.0.1", port: 9 }).increment(big); + }, + }); + withHandler.increment(big); +}); diff --git a/tests/fixtures/npm/cases/hot-shots-send-error/package.json b/tests/fixtures/npm/cases/hot-shots-send-error/package.json new file mode 100644 index 0000000000..5ffd9800b9 --- /dev/null +++ b/tests/fixtures/npm/cases/hot-shots-send-error/package.json @@ -0,0 +1 @@ +{ "type": "module" } diff --git a/tests/fixtures/npm/cases/hot-shots-tcp/main.ts b/tests/fixtures/npm/cases/hot-shots-tcp/main.ts new file mode 100644 index 0000000000..0812c90f18 --- /dev/null +++ b/tests/fixtures/npm/cases/hot-shots-tcp/main.ts @@ -0,0 +1,33 @@ +// The hot-shots StatsD client over tcp (compiled from scriptc's built-in +// shim): a send completes once the socket has written its line, so close() +// waits for lines that a full socket buffer holds back, and the receiver +// gets every line before the connection ends. +import * as net from "node:net"; +import { StatsD } from "hot-shots"; + +const LINES = 20000; +const name = "m".repeat(1000); +let bytes = 0; +let ended: () => void = () => {}; +const serverDone = new Promise((resolve) => { + ended = resolve; +}); +const server = net.createServer((socket) => { + socket.pause(); + setTimeout(() => socket.resume(), 150); + socket.on("data", (chunk: Buffer) => { + bytes += chunk.length; + }); + socket.on("end", () => ended()); +}); + +server.listen(0, "127.0.0.1", () => { + const port = (server.address() as net.AddressInfo).port; + const client = new StatsD({ host: "127.0.0.1", port, protocol: "tcp" }); + for (let i = 0; i < LINES; i++) client.increment(name); + const closed = new Promise((resolve) => client.close(() => resolve())); + void Promise.all([closed, serverDone]).then(() => { + console.log("closed; received", bytes, "of", LINES * (name.length + 5), "bytes"); + server.close(() => console.log("server closed")); + }); +}); diff --git a/tests/fixtures/npm/cases/hot-shots-tcp/package.json b/tests/fixtures/npm/cases/hot-shots-tcp/package.json new file mode 100644 index 0000000000..5ffd9800b9 --- /dev/null +++ b/tests/fixtures/npm/cases/hot-shots-tcp/package.json @@ -0,0 +1 @@ +{ "type": "module" } From fd40a8c84a136cdeaa18b08d5cf4c566e32eadd7 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 11:18:30 -0500 Subject: [PATCH 16/23] Try each PATH entry with exec when spawning with a replacement env The PATH lookup for spawns with an `env` option picked the first executable regular file and stopped there, so a script whose interpreter is missing ended the search with ENOENT. Node's libuv runs execvp in the child, which moves on to the next PATH entry when an exec fails with ENOENT, ENOTDIR or EACCES. Each candidate now runs through posix_spawn in order with the same rule, and relative entries are resolved by the child in its cwd. --- packages/runtime/src/scr_child.c | 76 +++++++--------------- tests/corpus/7036-child-env-path-lookup.ts | 15 ++++- 2 files changed, 36 insertions(+), 55 deletions(-) diff --git a/packages/runtime/src/scr_child.c b/packages/runtime/src/scr_child.c index c1d98b35b5..df75435009 100644 --- a/packages/runtime/src/scr_child.c +++ b/packages/runtime/src/scr_child.c @@ -2907,7 +2907,6 @@ void scr_children_poll(void) { #include #include #include -#include #include #include #include @@ -3112,21 +3111,23 @@ static ScrSpawnRes *scr_spawn_res_new(bool has_status, double status, static char **scr_exec_envp(ScrArr *pairs); static void scr_exec_envp_free(char **envp); -/* The executable `file` names when `envp` replaces the child's - * environment, found as libuv finds it: a name with a '/' is used as - * given; otherwise each entry of the replacement's PATH (an empty entry - * is the current directory), or of the default path when the replacement - * has no PATH, is tried in order. Relative candidates are checked from - * `cwd`, the directory the child starts in (NULL: this process's). Returns - * a malloc'd path, or NULL with *err set: EACCES when a candidate exists - * but cannot run, else ENOENT. */ -static char *scr_spawn_path_lookup(const char *file, char *const *envp, const char *cwd, - int *err) { - if (strchr(file, '/')) { - char *copy = strdup(file); - if (!copy) scr_child_oom(); - return copy; - } +/* posix_spawnp for the child_process spawns. Without `envp` the command + * resolves on this process's PATH over `environ`. With `envp` (a + * replacement environment) it resolves the way Node's libuv runs execvp + * in the child: a name with a '/' runs as given; otherwise each entry of + * the replacement's PATH (an empty entry is the current directory), or of + * the default path when the replacement has no PATH, is tried in order, + * and a candidate whose exec fails with ENOENT, ENOTDIR or EACCES (a + * missing file, or a script whose interpreter is missing) moves on to the + * next entry. The last such failure is EACCES if any candidate was denied, + * else ENOENT. Relative entries are resolved by the child, which starts in + * `cwd`. Returns posix_spawn's error number. */ +static int scr_spawn_command(pid_t *pid, const char *file, const posix_spawn_file_actions_t *fa, + const posix_spawnattr_t *attr, char *const *argv, + char *const *envp, const char *cwd) { + (void)cwd; /* the file actions change into it before the exec */ + if (envp == NULL) return posix_spawnp(pid, file, fa, attr, argv, environ); + if (strchr(file, '/')) return posix_spawn(pid, file, fa, attr, argv, envp); const char *path = "/usr/bin:/bin"; for (char *const *e = envp; *e; e++) { if (strncmp(*e, "PATH=", 5) == 0) { @@ -3135,7 +3136,6 @@ static char *scr_spawn_path_lookup(const char *file, char *const *envp, const ch } } size_t file_len = strlen(file); - size_t cwd_len = cwd ? strlen(cwd) : 0; bool denied = false; for (const char *dir = path;;) { const char *end = strchr(dir, ':'); @@ -3147,51 +3147,19 @@ static char *scr_spawn_path_lookup(const char *file, char *const *envp, const ch memcpy(candidate, prefix, prefix_len); candidate[prefix_len] = '/'; memcpy(candidate + prefix_len + 1, file, file_len + 1); - char *checked = candidate; - if (cwd_len > 0 && candidate[0] != '/') { - checked = malloc(cwd_len + 1 + strlen(candidate) + 1); - if (!checked) scr_child_oom(); - memcpy(checked, cwd, cwd_len); - checked[cwd_len] = '/'; - strcpy(checked + cwd_len + 1, candidate); - } - struct stat st; - bool runs = false; - if (stat(checked, &st) == 0) { - runs = S_ISREG(st.st_mode) && access(checked, X_OK) == 0; - if (!runs) denied = true; - } else if (errno == EACCES) { - denied = true; - } - if (checked != candidate) free(checked); - if (runs) return candidate; + int err = posix_spawn(pid, candidate, fa, attr, argv, envp); free(candidate); + if (err == EACCES) denied = true; + else if (err != ENOENT && err != ENOTDIR) return err; if (!end) break; dir = end + 1; } - *err = denied ? EACCES : ENOENT; - return NULL; -} - -/* posix_spawnp for the child_process spawns: with `envp` (a replacement - * environment) the command resolves on that environment's PATH - * (scr_spawn_path_lookup) as Node's does; without it, on this process's - * PATH over `environ`. Returns posix_spawn's error number. */ -static int scr_spawn_command(pid_t *pid, const char *file, const posix_spawn_file_actions_t *fa, - const posix_spawnattr_t *attr, char *const *argv, - char *const *envp, const char *cwd) { - if (envp == NULL) return posix_spawnp(pid, file, fa, attr, argv, environ); - int err = 0; - char *resolved = scr_spawn_path_lookup(file, envp, cwd, &err); - if (!resolved) return err; - err = posix_spawn(pid, resolved, fa, attr, argv, envp); - free(resolved); - return err; + return denied ? EACCES : ENOENT; } /* env_pairs: NULL inherits the parent's environment; else [k,v,...] * replaces it, as Node's `env` option does, and the command is looked up - * on the replacement's PATH (scr_spawn_path_lookup). */ + * on the replacement's PATH (scr_spawn_command). */ static ScrSpawnRes *scr_spawn_sync_core(ScrStr *cmd, ScrArr *args, double timeout_ms, int killsig, int in_mode, int out_mode, int err_mode, ScrArr *env_pairs) { diff --git a/tests/corpus/7036-child-env-path-lookup.ts b/tests/corpus/7036-child-env-path-lookup.ts index cac0670e9d..97c93d835c 100644 --- a/tests/corpus/7036-child-env-path-lookup.ts +++ b/tests/corpus/7036-child-env-path-lookup.ts @@ -11,6 +11,12 @@ mkdirSync(join(dir, "tools")); writeFileSync(join(dir, "tools", "child-tool"), "#!/bin/sh\necho child-tool $1\n"); chmodSync(join(dir, "tools", "child-tool"), 0o755); +// An earlier PATH entry holding a script whose interpreter is missing +// moves the lookup on to the next entry, as execvp does. +mkdirSync(join(dir, "broken")); +writeFileSync(join(dir, "broken", "child-tool"), "#!/nonexistent/interpreter\n"); +chmodSync(join(dir, "broken", "child-tool"), 0o755); + const show = (e: unknown): string => { const err = e as NodeJS.ErrnoException; return `${err.code} ${err.message.replace(dir, "")}`; @@ -23,11 +29,18 @@ try { } catch (e) { console.log(show(e)); } +const twoEntries = `${join(dir, "broken")}:${join(dir, "tools")}`; +console.log(execFileSync("child-tool", ["fallthrough"], { env: { PATH: twoEntries }, encoding: "utf8" }).trim()); +try { + execFileSync("child-tool", [], { env: { PATH: join(dir, "broken") }, encoding: "utf8" }); +} catch (e) { + console.log(show(e)); +} console.log( execFileSync("child-tool", ["relative"], { env: { PATH: "tools" }, cwd: dir, encoding: "utf8" }).trim(), ); -const child = spawn("child-tool", ["async"], { env: { PATH: join(dir, "tools") }, stdio: ["ignore", "pipe", "ignore"] }); +const child = spawn("child-tool", ["async"], { env: { PATH: twoEntries }, stdio: ["ignore", "pipe", "ignore"] }); let out = ""; child.stdout!.on("data", (chunk: Buffer) => (out += chunk.toString())); child.on("close", (code) => { From 8f08cbbec594caa07af7164bb57882209f81fbcd Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 13:09:01 -0500 Subject: [PATCH 17/23] Build Sets, Maps and weak collections from checked-dynamic iterables `new Set(x)`, `new Map(x)`, `new WeakSet(x)`, `new WeakMap(x)` and `Object.fromEntries(x)` now accept any checked-dynamic iterable, as in Node: a native iterator (`map.keys()`, `set.values()`), a compiled generator, an object with a Symbol.iterator method, or a Set. Before, a Set seed that was not an array or a string threw "is not iterable", and a Map, weak collection or Object.fromEntries seed that was a generator or a collection other than a Map refused with SC2020. The runtime drains native iterators, packs arrays, strings and collections, and steps every other iterable through its iterator (scr_dyn_seed_values). A program that builds these from an untyped seed registers the compiled generators' next and return methods with the runtime, as destructuring rest already did, so a generator seed can be stepped. The seed's values are all taken before the first one is added, so when an entry of a Map seed is not an object the TypeError comes after the iterable is exhausted; Node closes the iterator at that entry. The limitations page says so. --- .../limitations/builtin-apis/map-and-set.mdx | 2 ++ .../src/frontend/lowering/dispatch-sites.ts | 14 +++++++- .../6926-dynamic-collection-seeds.mjs.json | 6 ++++ .../6927-dynamic-collection-seeds.ts.json | 6 ++++ packages/runtime/src/scr_json.c | 32 +++++++++++-------- .../corpus/6926-dynamic-collection-seeds.mjs | 28 ++++++++++++++++ tests/corpus/6927-dynamic-collection-seeds.ts | 9 ++++++ .../6926-dynamic-collection-seeds.mjs.json | 1 + .../6927-dynamic-collection-seeds.ts.json | 1 + 9 files changed, 85 insertions(+), 14 deletions(-) create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6926-dynamic-collection-seeds.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6927-dynamic-collection-seeds.ts.json create mode 100644 tests/corpus/6926-dynamic-collection-seeds.mjs create mode 100644 tests/corpus/6927-dynamic-collection-seeds.ts create mode 100644 tests/harness/corpus-costs/6926-dynamic-collection-seeds.mjs.json create mode 100644 tests/harness/corpus-costs/6927-dynamic-collection-seeds.ts.json diff --git a/docs/content/limitations/builtin-apis/map-and-set.mdx b/docs/content/limitations/builtin-apis/map-and-set.mdx index bf77001ee6..ee7435b2de 100644 --- a/docs/content/limitations/builtin-apis/map-and-set.mdx +++ b/docs/content/limitations/builtin-apis/map-and-set.mdx @@ -7,4 +7,6 @@ They support `.next()`, `for...of`, array spreads, and mapper-less `Array.from`. They also support the iterator helper methods, such as `.map()` and `.take()`. Detached collection methods are unsupported. + Constructing a Map, Set, WeakMap or WeakSet, or calling `Object.fromEntries`, with a checked-dynamic iterable (a native iterator, a generator, or an object with a `Symbol.iterator` method) takes all of its values before adding the first one. + When an entry of a Map seed is not an object, the TypeError comes after the iterable is exhausted; Node closes the iterator at that entry. The Set composition methods (`union`, `intersection`, `difference`, `symmetricDifference`, `isSubsetOf`, `isSupersetOf`, `isDisjointFrom`) accept a Set of the same element type or a Map keyed by it; other set-like arguments are unsupported. diff --git a/packages/compiler/src/frontend/lowering/dispatch-sites.ts b/packages/compiler/src/frontend/lowering/dispatch-sites.ts index 2618dacf9a..c8a8d6ba61 100644 --- a/packages/compiler/src/frontend/lowering/dispatch-sites.ts +++ b/packages/compiler/src/frontend/lowering/dispatch-sites.ts @@ -11,6 +11,18 @@ import { everyStmtList } from "../../ir/traverse.js"; import { toPrimitiveHint } from "./class-dynamic-dispatch.js"; import { GENERATOR_STEP_METHODS, HELPER_METHODS } from "./generator-dynamic-dispatch.js"; +/** Runtime entry points that step a checked-dynamic iterable's iterator: + * destructuring rest, and the collection constructors' and + * Object.fromEntries' seeds. */ +const RUNTIME_STEP_LIB_FNS: ReadonlySet = new Set([ + "dyn.destructureRest", + "dyn.nativeSetNew", + "dyn.mapSeedEntries", + "dyn.fromEntries", + "weakMap.new", + "weakSet.new", +]); + /** What one function's body holds for the class dispatch pass and its * caught-value, generator and class construction sub-passes, collected in * one walk. Lists keep the order the walk meets their entries. */ @@ -186,7 +198,7 @@ function scanSites(statements: IrStmt[]): FunctionSites { expr.key.kind === "strLit" && HELPER_METHODS.has(expr.key.value)) || expr.kind === "dynIterN" || - (expr.kind === "libCall" && expr.fn === "dyn.destructureRest") + (expr.kind === "libCall" && RUNTIME_STEP_LIB_FNS.has(expr.fn)) ) sites.runtimeSteps = true; switch (expr.kind) { diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6926-dynamic-collection-seeds.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6926-dynamic-collection-seeds.mjs.json new file mode 100644 index 0000000000..32edfc4028 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6926-dynamic-collection-seeds.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6926-dynamic-collection-seeds.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6927-dynamic-collection-seeds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6927-dynamic-collection-seeds.ts.json new file mode 100644 index 0000000000..89c591dd78 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6927-dynamic-collection-seeds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6927-dynamic-collection-seeds.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_json.c b/packages/runtime/src/scr_json.c index 1c85a928ad..e4b66990d0 100644 --- a/packages/runtime/src/scr_json.c +++ b/packages/runtime/src/scr_json.c @@ -1577,6 +1577,20 @@ ScrDyn *scr_dyn_iter_pack(const ScrDyn *src, const ScrStr *msg) { static ScrDyn *scr_native_iterator_drain(const ScrDyn *src); +/* The values a collection constructor's iterable seed gives, in order: +1 + * array, or NULL with the exception pending. A native iterator (a Map's + * keys(), a Set's values()) drains, which runs no program code; arrays, + * strings, typed arrays and collections pack; other iterables (a + * generator, an object with a Symbol.iterator method) step their + * iterator to the end, so their values are all taken before the + * constructor adds the first one. */ +static ScrDyn *scr_dyn_seed_values(const ScrDyn *src) { + if (src->kind == SCR_DYN_HANDLE && + (src->v.handle.tag == SCR_DYNH_ITERATOR || scr_dyn_handle_ops_of(src)->iter_step)) + return scr_native_iterator_drain(src); + return scr_dyn_destructure_rest(src, NULL); +} + /* The for-of-over-dyn pack accessors: the emitted index loop drives them * over a scr_dyn_iter_pack result (ARR by construction — the defensive * arms cover nothing reachable from that lowering). Never throw. */ @@ -1592,18 +1606,10 @@ ScrDyn *scr_dyn_map_seed_entries(const ScrDyn *src) { if (scr_exc_pending()) return NULL; } /* A native iterator (sp.entries(), a Map's entries()) or a handle that - * steps through live entries (URLSearchParams): producing its entries - * runs no program code, so draining them first is what the consumer - * observes. */ - if (src->kind == SCR_DYN_HANDLE && - (src->v.handle.tag == SCR_DYNH_ITERATOR || scr_dyn_handle_ops_of(src)->iter_step)) - return scr_native_iterator_drain(src); - if (src->kind == SCR_DYN_HANDLE || src->kind == SCR_DYN_TYPED_REF) { - static const char message[] = "new Map(entries) over native non-array iterables has no lowering"; - scr_throw_error_msg_code(SCR_ERR_ERROR, message, sizeof message - 1, "SC2020"); - return NULL; - } - return scr_dyn_iter_pack(src, NULL); + * steps through live entries (URLSearchParams) drains; a Set, a + * generator or another iterable gives its values in order + * (scr_dyn_seed_values). */ + return scr_dyn_seed_values(src); } ScrDyn *scr_dyn_map_seed_entry(const ScrDyn *entry) { @@ -14836,7 +14842,7 @@ ScrDyn *scr_dyn_native_set(ScrMap *value) { ScrDyn *scr_dyn_native_set_new(const ScrDyn *seed) { ScrDyn *items = NULL; if (seed->kind != SCR_DYN_NULL && seed->kind != SCR_DYN_UNDEF) { - items = scr_dyn_iter_pack(seed, NULL); + items = scr_dyn_seed_values(seed); if (!items) return NULL; } ScrMap *set = scr_map_new(SCR_MAP_KEY_DYN, SCR_MAP_VAL_F64, &scr_map_dyn_set_ops); diff --git a/tests/corpus/6926-dynamic-collection-seeds.mjs b/tests/corpus/6926-dynamic-collection-seeds.mjs new file mode 100644 index 0000000000..a48fab894e --- /dev/null +++ b/tests/corpus/6926-dynamic-collection-seeds.mjs @@ -0,0 +1,28 @@ +// Set, Map, WeakSet and Object.fromEntries over checked-dynamic iterables: +// native iterators, generators, objects with a Symbol.iterator method and +// collections, as seeds that reach the runtime untyped. +function* pairs() { yield ["g", 1]; yield ["h", 2]; } +function* values() { yield 1; yield 2; yield 2; } +const iterable = { *[Symbol.iterator]() { yield ["i", 3]; } }; +const valueIterable = { *[Symbol.iterator]() { yield "a"; yield "b"; } }; +function attempt(label, make) { + try { console.log(label, make()); } catch (e) { console.log(label, "threw", e.name, e.message); } +} +function viaSet(x) { return new Set(x).size; } +function viaMap(x) { return [...new Map(x).keys()].join(); } +function viaWeakSet(x) { return new WeakSet(x).has(key); } +const key = {}; +const m = new Map([["a", 1], ["b", 2]]); +attempt("set keys()", () => viaSet(m.keys())); +attempt("set values()", () => viaSet(new Set([1, 2]).values())); +attempt("set generator", () => viaSet(values())); +attempt("set iterable", () => viaSet(valueIterable)); +attempt("set string", () => viaSet("abca")); +attempt("set number", () => viaSet(5)); +attempt("map generator", () => viaMap(pairs())); +attempt("map iterable", () => viaMap(iterable)); +attempt("map set", () => viaMap(new Set([["s", 1]]))); +attempt("map entries()", () => viaMap(m.entries())); +attempt("map bad entry", () => viaMap([1])); +attempt("weakset generator", () => viaWeakSet((function* () { yield key; })())); +attempt("fromEntries generator", () => JSON.stringify(Object.fromEntries(pairs()))); diff --git a/tests/corpus/6927-dynamic-collection-seeds.ts b/tests/corpus/6927-dynamic-collection-seeds.ts new file mode 100644 index 0000000000..c57433d57c --- /dev/null +++ b/tests/corpus/6927-dynamic-collection-seeds.ts @@ -0,0 +1,9 @@ +// Set and Map seeds held as any: native iterators and generators. +function* values(): Generator { yield 1; yield 2; yield 2; } +function* pairs(): Generator<[string, number]> { yield ["a", 1]; yield ["b", 2]; } +const m = new Map([["x", 1], ["y", 2]]); +const anyKeys: any = m.keys(); +const anyGen: any = values(); +const anyPairs: any = pairs(); +console.log(new Set(anyKeys).size, new Set(anyGen).size, new Map(anyPairs).size); +console.log(new Set(values()).size, new Map(pairs()).get("b"), new Set(m.values()).size); diff --git a/tests/harness/corpus-costs/6926-dynamic-collection-seeds.mjs.json b/tests/harness/corpus-costs/6926-dynamic-collection-seeds.mjs.json new file mode 100644 index 0000000000..b4a56f5c5d --- /dev/null +++ b/tests/harness/corpus-costs/6926-dynamic-collection-seeds.mjs.json @@ -0,0 +1 @@ +{ "plain": 3813, "san": 3374 } diff --git a/tests/harness/corpus-costs/6927-dynamic-collection-seeds.ts.json b/tests/harness/corpus-costs/6927-dynamic-collection-seeds.ts.json new file mode 100644 index 0000000000..93da087d29 --- /dev/null +++ b/tests/harness/corpus-costs/6927-dynamic-collection-seeds.ts.json @@ -0,0 +1 @@ +{ "plain": 2436, "san": 2273 } From fbe4067b3b3de092dd411845f6965c85524735cc Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 14:15:29 -0500 Subject: [PATCH 18/23] Skip emitter analysis walks whose answers are already known The LLVM emitter's constructor walks the whole module about 33 times. Several walks repeat work another already did, or run where the result is provably empty: - computePublishedTypes and computeCycleMutability run once and are shared (may-throw, immutable fields and traced shapes took their own). - The WebCrypto-asymmetric and Ed25519 runtime-feature conditions join the feature scan's one walk instead of walking the module again. - int32 slots: the fixpoint skips the write walk of a function without a candidate write, dynamicFieldStores stops once every field name is dynamic, and dynamicallyStoredFamilies returns early when no f64 field can be named by a dynamic store. - stableGlobals stops once no candidate is left, the second pass of findAppendedArrayLiterals and the target resolution of findConstantCallbacks run only when there is something to find, boxedUnionIds needs unions, and observesStacks walks for call sites and the "stack" literal only when a dynamic key asks. - everyModuleNode visits type trees without a closure per node. The emitted LLVM IR is unchanged. --- .../compiler/src/backend/cycle-analysis.ts | 9 ++- .../compiler/src/backend/cycle-mutability.ts | 16 ++++++ packages/compiler/src/backend/immutability.ts | 9 ++- .../backend/llvm/appended-array-literals.ts | 1 + .../src/backend/llvm/constant-callbacks.ts | 4 +- packages/compiler/src/backend/llvm/emitter.ts | 10 +++- .../src/backend/llvm/nullable-unions.ts | 2 + packages/compiler/src/backend/may-throw.ts | 10 +++- .../src/backend/stack-observations.ts | 42 +++++++++----- packages/compiler/src/ir/int32-slots.ts | 47 ++++++++++------ packages/compiler/src/ir/runtime-features.ts | 56 ++++++++++++++----- packages/compiler/src/ir/traverse.ts | 11 +++- 12 files changed, 159 insertions(+), 58 deletions(-) diff --git a/packages/compiler/src/backend/cycle-analysis.ts b/packages/compiler/src/backend/cycle-analysis.ts index aa624579f8..fbd96e8549 100644 --- a/packages/compiler/src/backend/cycle-analysis.ts +++ b/packages/compiler/src/backend/cycle-analysis.ts @@ -11,7 +11,7 @@ import { STRING, VOID, } from "../ir/ir.js"; -import { computeCycleMutability, fieldKey } from "./cycle-mutability.js"; +import { type CycleMutability, computeCycleMutability, fieldKey } from "./cycle-mutability.js"; /** Cycle capability for native code generation. * Nodes are shape units and unions; edges are the references their fields @@ -38,8 +38,10 @@ import { computeCycleMutability, fieldKey } from "./cycle-mutability.js"; export function computeTraced( mod: IrModule, stores?: DynamicFieldStores, + /** computeCycleMutability's answer for this module, when the caller has it. */ + precomputed?: CycleMutability, ): { shapes: Set; unions: Set } { - const { shapes, unions } = analyzeCycles(mod, false, stores); + const { shapes, unions } = analyzeCycles(mod, false, stores, precomputed); return { shapes, unions }; } @@ -93,6 +95,7 @@ function analyzeCycles( mod: IrModule, labels: boolean, stores?: DynamicFieldStores, + precomputed?: CycleMutability, ): { shapes: Set; unions: Set; @@ -125,7 +128,7 @@ function analyzeCycles( const lifetimeRoots = new Set(mod.contracts?.programLifetime ?? []); const programLifetime = (className: string): boolean => lifetimeRoots.size > 0 && lifetimeRoots.has(rootOf(className)); - const mutability = computeCycleMutability(mod, unitOfClass, stores); + const mutability = precomputed ?? computeCycleMutability(mod, unitOfClass, stores); const shapeDefs = [ ...classes.map((c) => ({ key: `object:${c.name}`, diff --git a/packages/compiler/src/backend/cycle-mutability.ts b/packages/compiler/src/backend/cycle-mutability.ts index 78daa62049..95630ef238 100644 --- a/packages/compiler/src/backend/cycle-mutability.ts +++ b/packages/compiler/src/backend/cycle-mutability.ts @@ -69,6 +69,22 @@ export function fieldKey(unit: string, field: string): string { return `${unit}\0${field}`; } +/** The cycle unit of a class: `object:`, the root of its hierarchy, + * as computeImmutableFields and computeTraced group classes. */ +export function hierarchyUnitOfClass(mod: IrModule): (className: string) => string { + const baseOf = new Map((mod.classes ?? []).map((c) => [c.name, c.base ?? null] as const)); + const roots = new Map(); + return (name) => { + const known = roots.get(name); + if (known !== undefined) return `object:${known}`; + let cur = name; + for (let base = baseOf.get(cur); base !== null && base !== undefined; base = baseOf.get(cur)) + cur = base; + roots.set(name, cur); + return `object:${cur}`; + }; +} + export function computeCycleMutability( mod: IrModule, unitOfClass: (className: string) => string, diff --git a/packages/compiler/src/backend/immutability.ts b/packages/compiler/src/backend/immutability.ts index 6c37731e38..21380de8fc 100644 --- a/packages/compiler/src/backend/immutability.ts +++ b/packages/compiler/src/backend/immutability.ts @@ -48,6 +48,8 @@ export class ImmutableFields { export function computeImmutableFields( mod: IrModule, stores?: DynamicFieldStores, + /** computeCycleMutability's answer for this module, when the caller has it. */ + precomputed?: CycleMutability, ): ImmutableFields | null { if (mod.lib !== undefined) return null; const baseOf = new Map((mod.classes ?? []).map((c) => [c.name, c.base ?? null] as const)); @@ -62,7 +64,7 @@ export function computeImmutableFields( return cur; }; const unitOfClass = (name: string): string => `object:${rootOf(name)}`; - const mutability = computeCycleMutability(mod, unitOfClass, stores); + const mutability = precomputed ?? computeCycleMutability(mod, unitOfClass, stores); return mutability.all ? null : new ImmutableFields(mutability, unitOfClass); } @@ -213,6 +215,9 @@ export function stableGlobals(mod: IrModule): Set { } return everyStmtChild(s, expr, stmt); }; - for (const fn of mod.functions) fn.body.every(stmt); + for (const fn of mod.functions) { + if (candidates.size === 0) break; + fn.body.every(stmt); + } return candidates; } diff --git a/packages/compiler/src/backend/llvm/appended-array-literals.ts b/packages/compiler/src/backend/llvm/appended-array-literals.ts index 1d4577ae63..09a2976de0 100644 --- a/packages/compiler/src/backend/llvm/appended-array-literals.ts +++ b/packages/compiler/src/backend/llvm/appended-array-literals.ts @@ -85,6 +85,7 @@ export function findAppendedArrayLiterals(module: IrModule): ReadonlySet for (const field of fieldAliases.get(binding) ?? []) appendedFields.add(field); const result = new Set(); + if (appendedBindings.size === 0 && appendedFields.size === 0) return result; const consider = (value: IrExpr | null, appended: boolean): void => { if (value && appended && isEmptyLiteral(value)) result.add(value); }; diff --git a/packages/compiler/src/backend/llvm/constant-callbacks.ts b/packages/compiler/src/backend/llvm/constant-callbacks.ts index 8a898d6a09..cf5c1b0623 100644 --- a/packages/compiler/src/backend/llvm/constant-callbacks.ts +++ b/packages/compiler/src/backend/llvm/constant-callbacks.ts @@ -252,11 +252,13 @@ export function findConstantCallbacks( // entries actually used as indirect callees in each body. A module-wide // global/function cross product would dominate large-source emission. const globalTargets = new Map(); + const result = new Map>(); + // Only indirect callees get targets: without one, nothing resolves. + if (![...indirectCallees.values()].some((callees) => callees.size > 0)) return result; for (const [id, value] of globals) { const target = resolve(null, value); if (target) globalTargets.set(id, target); } - const result = new Map>(); for (const fn of mod.functions) { const needed = indirectCallees.get(fn.name)!; if (!needed.size) continue; diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index bfde59a309..d0cbe54e26 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -175,6 +175,7 @@ import { emitDynamicExpr } from "./expr-dynamic.js"; import { emitIntrinsicExpr, emitSerializationExpr, emitAsyncExpr } from "./expr-async.js"; import { PublishWalkers } from "./publish.js"; import { computeImmutableFields, stableGlobals, type ImmutableFields } from "../immutability.js"; +import { computeCycleMutability, hierarchyUnitOfClass } from "../cycle-mutability.js"; import { computePublishedTypes, type PublishedTypes } from "../publication.js"; import { emitExpr } from "./expr-dispatch.js"; @@ -1312,8 +1313,10 @@ export class LlEmitter { // and per async fiber; WASI, Windows and library builds have none. const triple = (options.targetTriple ?? "").toLowerCase(); const windows = triple === "" ? process.platform === "win32" : triple.includes("windows"); + this.publishedTypes = computePublishedTypes(mod); const mt = computeMayThrow(mod, { stackChecks: !this.wasi && mod.lib === undefined && !windows, + published: this.publishedTypes, }); this.mayThrow = mt.fns; this.workerEntryPolls = mt.workerEntryPolls ?? null; @@ -1322,11 +1325,12 @@ export class LlEmitter { // runtime moves deep prefix nests to a fresh stack using the guard, // which Windows lacks. this.stacklessAsyncAllowed = this.stacklessGenerators && mod.lib === undefined && !windows; - this.publishedTypes = computePublishedTypes(mod); this.unframedFunctions = this.stackTraces ? captureFreeFunctions(mod, this.stackChecks, this.publishedTypes) : new Set(); - this.immutableFields = computeImmutableFields(mod, dynamicStores); + // One field-mutability answer serves immutable fields and traced shapes. + const cycleMutability = computeCycleMutability(mod, hierarchyUnitOfClass(mod), dynamicStores); + this.immutableFields = computeImmutableFields(mod, dynamicStores, cycleMutability); this.constructorFunctions = new Set((mod.classes ?? []).map((c) => `%${c.name}.constructor`)); this.indirectMayThrow = mt.indirect || mod.workers === true; for (const cls of mod.classes ?? []) { @@ -1451,7 +1455,7 @@ export class LlEmitter { this.receiverReaders = new AmbientReceiverReaders(this.fnByName); this.stackCaptures = new StackCaptures(this.fnByName, this.callLifetimes, this.stackCallbacks); this.lazyCaptures = new LazyCaptures(this.fnByName); - const traced = computeTraced(mod, dynamicStores); + const traced = computeTraced(mod, dynamicStores, cycleMutability); this.tracedShapes = traced.shapes; this.tracedUnions = traced.unions; // A shape union's value is whichever record it holds, and the collector diff --git a/packages/compiler/src/backend/llvm/nullable-unions.ts b/packages/compiler/src/backend/llvm/nullable-unions.ts index 8729e96494..2c355f5517 100644 --- a/packages/compiler/src/backend/llvm/nullable-unions.ts +++ b/packages/compiler/src/backend/llvm/nullable-unions.ts @@ -279,6 +279,8 @@ function shapeUnion( * tag and payload inside the C map. */ function boxedUnionIds(mod: IrModule): Set { const boxed = new Set(); + // Only the module's union definitions consult the result. + if (!mod.unions?.length) return boxed; const mark = (t: IrType): void => { if (t.kind === "union") boxed.add(t.unionId); }; diff --git a/packages/compiler/src/backend/may-throw.ts b/packages/compiler/src/backend/may-throw.ts index b72dc545db..a04cce856f 100644 --- a/packages/compiler/src/backend/may-throw.ts +++ b/packages/compiler/src/backend/may-throw.ts @@ -35,7 +35,12 @@ export type MayThrowReason = * and a generator's `.return()` unwind through `catch`. */ export function computeMayThrow( mod: IrModule, - options: { stackChecks?: boolean; explain?: boolean } = {}, + options: { + stackChecks?: boolean; + explain?: boolean; + /** computePublishedTypes(mod), when the caller already has it. */ + published?: ReturnType; + } = {}, ): { fns: Set; /** With `explain`: the reason each may-throw function was marked. */ @@ -50,7 +55,8 @@ export function computeMayThrow( const terminations = mod.workers === true ? workerTerminationPolls(mod) : null; const stackChecks = options.stackChecks === true ? stackCheckedFunctions(mod) : null; // Stores that can reach a published object throw the frozen TypeError. - const published = computePublishedTypes(mod); + const published = + options.published !== undefined ? options.published : computePublishedTypes(mod); interface Facts { throws: boolean; callees: string[]; diff --git a/packages/compiler/src/backend/stack-observations.ts b/packages/compiler/src/backend/stack-observations.ts index fa67c071ff..c448897f19 100644 --- a/packages/compiler/src/backend/stack-observations.ts +++ b/packages/compiler/src/backend/stack-observations.ts @@ -29,35 +29,50 @@ const NON_STACK_KEY_TYPES: ReadonlySet = new Set(["f64", "bigint * containers or calls; a key the program assembles from other strings or * from data it reads keeps the static answer. */ class StackKeys { - private readonly spelled: boolean; - private readonly calls = new Map(); - private readonly named: Set; + private spelled: boolean | undefined; + private census: + | { calls: Map; named: Set } + | undefined; private readonly inits = new Map>(); /** Settled answers by function and local: true where a search reached a * key that can be "stack", false where a search that found none passed. */ private readonly answers = new Map(); - constructor(mod: IrModule) { - this.spelled = spellsStack(mod); - this.named = new Set(moduleFunctionReferences(mod)); + // The module walks run on the first question that needs them: a program + // without a dynamic key read asks none. + constructor(private readonly mod: IrModule) {} + + private spellsStack(): boolean { + return (this.spelled ??= spellsStack(this.mod)); + } + + private callCensus(): { + calls: Map; + named: Set; + } { + if (this.census !== undefined) return this.census; + const mod = this.mod; + const calls = new Map(); + const named = new Set(moduleFunctionReferences(mod)); // Class methods, accessors and constructors are called through dispatch. const classNames = new Set((mod.classes ?? []).map((cls) => cls.name)); for (const fn of mod.functions) { - if (isClassMember(fn.name, classNames)) this.named.add(fn.name); + if (isClassMember(fn.name, classNames)) named.add(fn.name); everyStmtList(fn.body, { stmt: () => true, expr: (expr) => { if (expr.kind === "call") { - const sites = this.calls.get(expr.callee) ?? []; + const sites = calls.get(expr.callee) ?? []; sites.push({ caller: fn, args: expr.args }); - this.calls.set(expr.callee, sites); + calls.set(expr.callee, sites); } const referenced = exprFunctionReference(expr); - if (referenced !== undefined) this.named.add(referenced); + if (referenced !== undefined) named.add(referenced); return true; }, }); } + return (this.census = { calls, named }); } mayBeStack(fn: IrFunction, key: IrExpr): boolean { @@ -71,7 +86,7 @@ class StackKeys { private keyMayBeStack(fn: IrFunction, key: IrExpr, visited: Set): boolean { if (key.kind === "strLit") return key.value === "stack"; - if (!this.spelled) return false; + if (!this.spellsStack()) return false; if (NON_STACK_KEY_TYPES.has(key.type.kind)) return false; if (key.kind === "toString" && NON_STACK_KEY_TYPES.has(key.operand.type.kind)) return false; if (key.kind === "dynFrom" && NON_STACK_KEY_TYPES.has(key.value.type.kind)) return false; @@ -93,8 +108,9 @@ class StackKeys { if (local === undefined || local.mutable) return true; const index = fn.params.findIndex((param) => param.localId === localId); if (index !== -1) { - const sites = this.calls.get(fn.name); - if (this.named.has(fn.name) || sites === undefined) return true; + const { calls, named } = this.callCensus(); + const sites = calls.get(fn.name); + if (named.has(fn.name) || sites === undefined) return true; return sites.some( (site) => site.args.length !== fn.params.length || diff --git a/packages/compiler/src/ir/int32-slots.ts b/packages/compiler/src/ir/int32-slots.ts index 21223862a4..ac07472762 100644 --- a/packages/compiler/src/ir/int32-slots.ts +++ b/packages/compiler/src/ir/int32-slots.ts @@ -508,7 +508,10 @@ export function dynamicFieldStores( }; const dynWritten = new Set(); let dynWritesAll = false; - for (const fn of mod.functions) + // A store whose key is not a literal names every field: later stores add + // nothing, so the walk stops there. + for (const fn of mod.functions) { + if (dynWritesAll) break; walkFunction(fn, { expr: (e) => { if (dynWritesAll) return; @@ -524,6 +527,7 @@ export function dynamicFieldStores( } }, }); + } return { all: dynWritesAll, names: dynWritten }; } @@ -536,6 +540,22 @@ export function dynamicallyStoredFamilies( slots: Int32Slots, stores?: DynamicFieldStores, ): Set { + const records = new Map((mod.records ?? []).map((r) => [r.id, r])); + const unions = new Map((mod.unions ?? []).map((u) => [u.id, u])); + // A live dyn view (typed-ref capsule) of an instance writes back into + // its fields only after a runtime store into the capsule; the commit then + // writes every field from the view, which holds the exact snapshot value + // of any property no store named. So reaching dynamic code disqualifies + // exactly the field names some dynamic store in the program can name. + const { all: dynWritesAll, names: dynWritten } = + stores ?? dynamicFieldStores(mod, records, unions); + const storable = (field: { name: string; type: IrType }): boolean => + field.type.kind === "f64" && + !field.name.startsWith("%") && + (dynWritesAll || dynWritten.has(field.name)); + const families = new Set(); + // Without a field some store can name, no class is worth exposing. + if (!(mod.classes ?? []).some((cls) => cls.fields.some(storable))) return families; const classes = new Map((mod.classes ?? []).map((c) => [c.name, c])); const children = new Map(); for (const cls of classes.values()) @@ -554,8 +574,6 @@ export function dynamicallyStoredFamilies( } return out; }; - const records = new Map((mod.records ?? []).map((r) => [r.id, r])); - const unions = new Map((mod.unions ?? []).map((u) => [u.id, u])); const exposedClasses = new Set(); const seenNamed = new Set(); let exposeAll = false; @@ -596,13 +614,6 @@ export function dynamicallyStoredFamilies( }); } }; - // A live dyn view (typed-ref capsule) of an instance writes back into - // its fields only after a runtime store into the capsule; the commit then - // writes every field from the view, which holds the exact snapshot value - // of any property no store named. So reaching dynamic code disqualifies - // exactly the field names some dynamic store in the program can name. - const { all: dynWritesAll, names: dynWritten } = - stores ?? dynamicFieldStores(mod, records, unions); for (const fn of mod.functions) walkFunction(fn, { expr: (e) => { @@ -628,16 +639,10 @@ export function dynamicallyStoredFamilies( if (s.kind === "throw") expose(s.value.type); }, }); - const families = new Set(); for (const cls of classes.values()) { if (!exposeAll && !exposedClasses.has(cls.name)) continue; for (const field of cls.fields) - if ( - field.type.kind === "f64" && - !field.name.startsWith("%") && - (dynWritesAll || dynWritten.has(field.name)) - ) - families.add(slots.family(cls.name, field.name)!); + if (storable(field)) families.add(slots.family(cls.name, field.name)!); } return families; } @@ -1058,12 +1063,18 @@ export function analyzeInt32Slots(mod: IrModule, inputs: Int32SlotInputs = {}): if (params) for (const id of params.keys()) reads(`param:${fn.name}\0${id}`, fn.name); // Range facts are consulted only at writes into candidate slots; slots // are only ever dropped, so a body without such a write needs none. - const ranges: IntegerRanges = hasCandidateWrite(fn) + const candidate = hasCandidateWrite(fn); + const ranges: IntegerRanges = candidate ? analyzeIntegerRanges(numeric(fn), slots.facts(fn.name)) : new Map(); if (ranges.size > 0) lastWrites.set(fn.name, slotWrites(fn, ranges, functions)); else lastWrites.delete(fn.name); const proven: IrExpr[] = []; + // The walk below acts only at writes into candidate slots. + if (!candidate) { + provenByFunction.set(fn.name, proven); + continue; + } const int32 = (e: IrExpr): boolean => withinInt32(ranges.get(e)); // An int32 written into a slot still assumed non-negative: widen the // assumption when the value may be negative, and reanalyze its readers. diff --git a/packages/compiler/src/ir/runtime-features.ts b/packages/compiler/src/ir/runtime-features.ts index 5b984f318d..f8b5e8dcc3 100644 --- a/packages/compiler/src/ir/runtime-features.ts +++ b/packages/compiler/src/ir/runtime-features.ts @@ -605,14 +605,23 @@ const STDIO_EXTENDED_NAMES: ReadonlySet = new Set(["setEncoding", "resiz /** The libCall nodes the rules below test. */ type LibCallNode = IrExpr & { kind: "libCall" }; +/** A condition over several nodes of the module (a WebCrypto call and an + * algorithm name): the scan's one walk shows it every expression, and the + * feature is set when `result` answers true after the walk. */ +interface RuleScan { + expr(node: IrExpr): void; + result(): boolean; +} + /** What makes a program need one optional runtime unit. The feature is set * when any condition holds: `initial` from the module's declarations, a * libCall named in `fns` or starting with one of `prefixes`, a libCall - * `libCall` accepts, another expression node `expr` accepts, or a type - * slot of one of the `types` kinds. A libCall or type that needs several - * units appears in each unit's rule. */ + * `libCall` accepts, another expression node `expr` accepts, a type slot of + * one of the `types` kinds, or a `scan` over the whole module. A libCall or + * type that needs several units appears in each unit's rule. */ interface RuntimeFeatureRule { initial?: (mod: IrModule) => boolean; + scan?: () => RuleScan; fns?: readonly IrLibFn[]; prefixes?: readonly string[]; libCall?: (node: LibCallNode) => boolean; @@ -650,17 +659,32 @@ const WEBCRYPTO_ASYMMETRIC_NAMES: ReadonlySet = new Set([ /** Whether a string literal in the module names Ed25519, without regard * to case ("ed25519" for node:crypto, "Ed25519" for WebCrypto): the * Ed25519 unit links then, alongside the pki unit. */ -export function moduleNamesEd25519(mod: IrModule): boolean { +function ed25519NameScan(): RuleScan { let named = false; - everyModuleNode(mod, { + return { expr: (node) => { - if (node.kind === "strLit" && node.value.toLowerCase() === "ed25519") named = true; - return !named; + if (!named && node.kind === "strLit" && node.value.toLowerCase() === "ed25519") named = true; }, - stmt: () => !named, - type: () => true, - }); - return named; + result: () => named, + }; +} + +/** moduleUsesWebCryptoAsymmetric's condition as a runtime-feature scan. */ +function webCryptoAsymmetricScan(): RuleScan { + let webcrypto = false; + let named = false; + return { + expr: (node) => { + if (node.kind === "libCall" && node.fn.startsWith("webcrypto.")) webcrypto = true; + else if ( + !named && + node.kind === "strLit" && + WEBCRYPTO_ASYMMETRIC_NAMES.has(node.value.toLowerCase()) + ) + named = true; + }, + result: () => webcrypto && named, + }; } /** Whether the module calls WebCrypto and a string literal in it names one @@ -906,10 +930,10 @@ const RUNTIME_FEATURE_RULES = { perfLoop: rule({ fns: ["perf.idleTime"], prefixes: ["perf.loop", "perf.eld"] }), /** scr_pki.c over the mbedTLS archive: asymmetric KeyObjects and * signatures. */ - pki: rule({ initial: moduleUsesWebCryptoAsymmetric, fns: [...PKI_LIB_FNS] }), + pki: rule({ scan: webCryptoAsymmetricScan, fns: [...PKI_LIB_FNS] }), /** scr_ed25519.c (the vendored libsodium Ed25519), linked with pki: a * string literal in the module names Ed25519. */ - ed25519: rule({ initial: moduleNamesEd25519 }), + ed25519: rule({ scan: ed25519NameScan }), processEvents: rule({ fns: [...PROCESS_EVENT_LIB_FNS, "util.styleText"], types: ["procStream"] }), /** scr_url_legacy.c parses and stringifies queries. */ qs: rule({ fns: [...QS_LIB_FNS, ...LEGACY_URL_LIB_FNS] }), @@ -1070,9 +1094,11 @@ for (const name of RUNTIME_FEATURE_NAMES) { function scanRuntimeFeatures(mod: IrModule, stopAt?: RuntimeFeatureName): RuntimeFeatures { const features = noRuntimeFeatures(); + const scans: { name: RuntimeFeatureName; scan: RuleScan }[] = []; for (const name of RUNTIME_FEATURE_NAMES) { - const initial = ruleOf(name).initial; + const { initial, scan } = ruleOf(name); if (initial && initial(mod)) features[name] = true; + if (scan) scans.push({ name, scan: scan() }); } const keepGoing = (): boolean => stopAt === undefined || !features[stopAt]; let tables: TypeTables | undefined; @@ -1083,6 +1109,7 @@ function scanRuntimeFeatures(mod: IrModule, stopAt?: RuntimeFeatureName): Runtim classes: new Map((mod.classes ?? []).map((c) => [c.name, c])), }); const expr = (node: IrExpr): boolean => { + for (let i = 0; i < scans.length; i++) scans[i]!.scan.expr(node); if (node.kind === "libCall") { const fn = node.fn; for (const name of FEATURES_BY_FN.get(fn) ?? []) features[name] = true; @@ -1101,6 +1128,7 @@ function scanRuntimeFeatures(mod: IrModule, stopAt?: RuntimeFeatureName): Runtim return keepGoing(); }; if (keepGoing()) everyModuleNode(mod, { expr, stmt: keepGoing, type }); + for (const { name, scan } of scans) if (scan.result()) features[name] = true; // Inline-cache sites of dynamic-tier functions use the tier's shapes // (scr_js_object.c, with the SCR_JS_TIER build of scr_json.c). if (!features.dynTier && mod.functions.some((fn) => fn.tier === "dynamic")) { diff --git a/packages/compiler/src/ir/traverse.ts b/packages/compiler/src/ir/traverse.ts index 11b20a210e..251904351b 100644 --- a/packages/compiler/src/ir/traverse.ts +++ b/packages/compiler/src/ir/traverse.ts @@ -109,8 +109,15 @@ export interface IrModuleVisitor extends IrVisitor { * source text, locations, labels, or other metadata. A false predicate stops * the whole walk. Results are never retained across mutable compiler passes. */ export function everyModuleNode(mod: IrModule, visitor: IrModuleVisitor): boolean { - const type = (node: IrType, loc: SrcLoc): boolean => - visitor.type(node, loc) && everyTypeChild(node, (child) => type(child, loc)); + // Every node of one type tree reports the tree's location: one shared + // child callback serves them all. + let typeLoc: SrcLoc; + const typeNode = (node: IrType): boolean => + visitor.type(node, typeLoc) && everyTypeChild(node, typeNode); + const type = (node: IrType, loc: SrcLoc): boolean => { + typeLoc = loc; + return typeNode(node); + }; const expr = (node: IrExpr): boolean => visitor.expr(node) && everyExprChild(node, expr, stmt) && type(node.type, node.loc); const stmt = (node: IrStmt): boolean => visitor.stmt(node) && everyStmtChild(node, expr, stmt); From f5a3faf18d642a52ac2bf0464abfac117903593d Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 14:25:55 -0500 Subject: [PATCH 19/23] Bound the compiler's cyclic garbage to twice its live heap The cycle collector widens the growth fraction that schedules full passes up to 16 times the heap left by the last pass while passes find little. Lowering a large program leaves hundreds of megabytes of cyclic garbage, and whether a scheduled pass reclaims it before the build's peak depends on where the growth rule fires: small changes to the compiler moved the peak of a tsc-ts build between 1.66 and 2.05 GB. The native compiler now sets the growth cap to 2 at startup, as SCR_CYCLE_GROWTH_CAP=2 does, so a full pass runs once the heap has grown to three times its size after the last one. scr_cyc_set_growth_cap sets the cap for a program from its own code; the environment variable still takes precedence, and child processes are not affected. --- packages/compiler/native/host.c | 15 +++++++++++++++ packages/compiler/native/host.ffi.json | 3 ++- packages/compiler/src/native/cli.ts | 2 ++ packages/runtime/src/scr_cycle.c | 25 ++++++++++++++++++++----- packages/runtime/src/scr_rc.h | 4 ++++ packages/runtime/test/test_cycle.c | 22 ++++++++++++++++++++++ 6 files changed, 65 insertions(+), 6 deletions(-) diff --git a/packages/compiler/native/host.c b/packages/compiler/native/host.c index 6aa1b2a285..457774f817 100644 --- a/packages/compiler/native/host.c +++ b/packages/compiler/native/host.c @@ -56,3 +56,18 @@ void scr_collect_cycles_phase(void); void scriptc_native_collect_cycles(void) { scr_collect_cycles_phase(); } + +/* The runtime's growth cap for full cycle passes (scr_rc.h). */ +void scr_cyc_set_growth_cap(long cap); + +/* Bounds the cyclic garbage a build can hold to twice its live heap. + * Lowering a large program leaves hundreds of megabytes of cyclic garbage, + * and whether a scheduled full pass reclaims it before the build's peak + * depends on where the growth rule fires: with the default cap of 16, small + * changes to the compiler moved the peak of one build by 390 MB. With a cap + * of 2 a full pass runs once the heap has grown to three times its size + * after the last one; a cap of 1 bounds the garbage further but runs more + * passes over the live heap. SCR_CYCLE_GROWTH_CAP still overrides it. */ +void scriptc_native_bound_cycle_growth(void) { + scr_cyc_set_growth_cap(2); +} diff --git a/packages/compiler/native/host.ffi.json b/packages/compiler/native/host.ffi.json index d7e0e92aae..3d15a1e0ec 100644 --- a/packages/compiler/native/host.ffi.json +++ b/packages/compiler/native/host.ffi.json @@ -2,6 +2,7 @@ "ffi_format": 6, "functions": [ { "name": "compilerNativePrivateDirectory", "symbol": "scriptc_native_private_directory", "params": ["string", "bool"], "returns": "bool" }, - { "name": "compilerNativeCollectCycles", "symbol": "scriptc_native_collect_cycles", "params": [], "returns": "void" } + { "name": "compilerNativeCollectCycles", "symbol": "scriptc_native_collect_cycles", "params": [], "returns": "void" }, + { "name": "compilerNativeBoundCycleGrowth", "symbol": "scriptc_native_bound_cycle_growth", "params": [], "returns": "void" } ] } diff --git a/packages/compiler/src/native/cli.ts b/packages/compiler/src/native/cli.ts index e2c3a895b4..d073df5f43 100644 --- a/packages/compiler/src/native/cli.ts +++ b/packages/compiler/src/native/cli.ts @@ -23,8 +23,10 @@ import { runCompilerTask } from "./task.js"; declare function compilerNativePrivateDirectory(path: string, harden: boolean): boolean; declare function compilerNativeCollectCycles(): void; +declare function compilerNativeBoundCycleGrowth(): void; async function main(): Promise { + compilerNativeBoundCycleGrowth(); setFrontendDisposedHook(() => compilerNativeCollectCycles()); const manifestPath = process.env["SCRIPTC_TOOLCHAIN"] ?? process.execPath + ".json"; let compiler: NativeCompiler | null = null; diff --git a/packages/runtime/src/scr_cycle.c b/packages/runtime/src/scr_cycle.c index 5e5029e149..844c47001d 100644 --- a/packages/runtime/src/scr_cycle.c +++ b/packages/runtime/src/scr_cycle.c @@ -529,7 +529,8 @@ static SCR_TL size_t scr_cyc_live_after[SCR_CYC_NGENS]; * large program, say) those walks dominate collection time. The cap trades * that walking for memory only when passes find nothing: while they find * garbage, the yield keeps the fraction narrow. SCR_CYCLE_GROWTH_CAP lowers - * the cap for memory-sensitive programs: a power of two from 1 to 16, with + * the cap for memory-sensitive programs, as scr_cyc_set_growth_cap does for + * a program that sets its own: a power of two from 1 to 16, with * other positive values rounded down to a power of two and larger ones read * as 16. At 1 the heap may at most double past its size after the last pass * at a level before the next. */ @@ -539,20 +540,34 @@ static SCR_TL unsigned char scr_cyc_growth_shift[SCR_CYC_NGENS]; static SCR_TL unsigned char scr_cyc_growth_streak[SCR_CYC_NGENS]; #endif +/* The growth cap a program sets for itself (scr_cyc_set_growth_cap), 0 for + * the default; SCR_CYCLE_GROWTH_CAP takes precedence over it. */ +static long scr_cyc_growth_cap_set = 0; +static SCR_TL unsigned char scr_cyc_growth_max_shift_cached = 0; + /* Shift of the configured growth cap: 2 + log2(cap), since the base * fraction is 1/4. */ static unsigned scr_cyc_growth_max_shift(void) { - static SCR_TL unsigned char cached = 0; - if (cached == 0) { + if (scr_cyc_growth_max_shift_cached == 0) { const char *env = scr_getenv("SCR_CYCLE_GROWTH_CAP"); long v = env ? strtol(env, NULL, 10) : 0; + if (v <= 0) v = scr_cyc_growth_cap_set; unsigned shift = SCR_CYC_GROWTH_MAX_SHIFT; if (v > 0) for (shift = 2; shift < SCR_CYC_GROWTH_MAX_SHIFT && (2L << (shift - 2)) <= v;) shift++; - cached = (unsigned char)shift; + scr_cyc_growth_max_shift_cached = (unsigned char)shift; } - return cached; + return scr_cyc_growth_max_shift_cached; +} + +void scr_cyc_set_growth_cap(long cap) { + scr_cyc_growth_cap_set = cap; + scr_cyc_growth_max_shift_cached = 0; + /* Fractions already widened past the new cap start at it. */ + unsigned max = scr_cyc_growth_max_shift(); + for (unsigned gen = 0; gen < SCR_CYC_NGENS; gen++) + if (scr_cyc_growth_shift[gen] > max) scr_cyc_growth_shift[gen] = (unsigned char)max; } /* Doublings of each generation's backlog threshold earned by consecutive diff --git a/packages/runtime/src/scr_rc.h b/packages/runtime/src/scr_rc.h index 7a921b4511..18df3a2371 100644 --- a/packages/runtime/src/scr_rc.h +++ b/packages/runtime/src/scr_rc.h @@ -670,6 +670,10 @@ static inline void scr_cyc_dead(void *obj) { * live heap — do not put it on a per-turn path. */ void scr_collect_cycles(void); void scr_collect_cycles_phase(void); +/* Sets the growth cap SCR_CYCLE_GROWTH_CAP sets (scr_cycle.c), for a program + * that knows its own memory profile; the environment variable takes + * precedence. Call it before the program allocates much. */ +void scr_cyc_set_growth_cap(long cap); void scr_cyc_context_cleanup(void); /* One pass on the normal generational schedule, for callers that reach a diff --git a/packages/runtime/test/test_cycle.c b/packages/runtime/test/test_cycle.c index 4e00b852e8..160083d6b4 100644 --- a/packages/runtime/test/test_cycle.c +++ b/packages/runtime/test/test_cycle.c @@ -536,6 +536,27 @@ static void check_mixed_dead_structure_narrows(void) { check(live <= narrowed, "a pass that freed a dead mature and old structure did not narrow the growth fraction"); } +/* scr_cyc_set_growth_cap sets the cap SCR_CYCLE_GROWTH_CAP sets, and a + * fraction already widened past it starts at it: after passes that found + * nothing widened the old level's fraction to the configured cap, a cap of + * 1 has the next dead cycle go once the heap has doubled past the floor. + * Restores the configured cap. */ +static void check_program_growth_cap(void) { + enum { FLOOR = 4096 }; + if (getenv("SCR_CYCLE_GROWTH_CAP") != NULL) return; /* it takes precedence */ + size_t slack = 2 * configured_nursery_threshold() + 2; + size_t live = 0; + for (int i = 0; i < 4; i++) live = grow_dead_cycle_until_full_pass(0, false); + check(live > FLOOR + FLOOR * configured_growth_cap(), + "passes that found nothing did not widen the growth fraction to the cap"); + scr_cyc_set_growth_cap(1); + for (int i = 0; i < 4; i++) { + live = grow_dead_cycle_until_full_pass(0, false); + check(live <= FLOOR + FLOOR + slack, "a program's growth cap of 1 did not bound the heap"); + } + scr_cyc_set_growth_cap(0); +} + /* The phase sweep (scr_collect_cycles_phase) is for a caller that knows a * phase's data has just died: it sweeps, and the growth schedule starts * over. After passes that find nothing have widened the old level's @@ -1500,6 +1521,7 @@ int main(void) { check_large_old_buffer_with_nursery_candidates(); check_unjudged_backlog_follows_growth(); check_acyclic_objects(); + check_program_growth_cap(); printf("cycle collection checks passed: threshold=%zu growth_cap=%zu\n", configured_nursery_threshold(), configured_growth_cap()); return 0; From fa62abce4dd178d0d2d2acf022ac72ddbdc793c1 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 16:45:06 -0500 Subject: [PATCH 20/23] Keep record types acyclic when only result-slot stores write their fields The backend gives every function that returns a complete record literal a result-slot entry, `%into.(...params, dst)`, which stores the literal's fields into caller frame storage. The cycle analysis counted those stores as writes after construction, so a record type that refers to itself and is never written after construction carried the cycle collector's header, its live count and its candidate checks in release builds, even when nothing called the entry. Dev builds, which add no entries, left it acyclic. The destination is frame storage of a caller that only projects the value (stack-objects.ts): no object can point to it, so its fields cannot lie on a cycle. computeCycleMutability now skips those stores, under the same condition emit-statements.ts already uses to emit them as initializations (resultSlotStore in the new result-slots.ts). Every other store still makes its field mutable. The same facts mark such fields as never replaced, so reads of them borrow instead of retaining. A program that rebuilds a tree of 2^21 - 1 object literals 12 times runs in 1.19 s instead of 1.35 s and peaks at 68 MB instead of 84 MB: each node is 32 bytes instead of 40. --- .../src/backend/cycle-analysis.test.ts | 56 ++++++++++++ .../compiler/src/backend/cycle-mutability.ts | 8 +- .../src/backend/llvm/emit-statements.ts | 10 +-- .../src/backend/llvm/record-results.ts | 15 +--- packages/compiler/src/backend/result-slots.ts | 29 +++++++ .../7261-acyclic-result-builders.ts.json | 6 ++ tests/corpus/7261-acyclic-result-builders.ts | 86 +++++++++++++++++++ .../7261-acyclic-result-builders.ts.json | 1 + 8 files changed, 189 insertions(+), 22 deletions(-) create mode 100644 packages/compiler/src/backend/result-slots.ts create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7261-acyclic-result-builders.ts.json create mode 100644 tests/corpus/7261-acyclic-result-builders.ts create mode 100644 tests/harness/corpus-costs/7261-acyclic-result-builders.ts.json diff --git a/packages/compiler/src/backend/cycle-analysis.test.ts b/packages/compiler/src/backend/cycle-analysis.test.ts index c78420f73e..340ffa8f9d 100644 --- a/packages/compiler/src/backend/cycle-analysis.test.ts +++ b/packages/compiler/src/backend/cycle-analysis.test.ts @@ -17,6 +17,7 @@ import { } from "../ir/ir.js"; import { computeTraced, explainCycle } from "./cycle-analysis.js"; import { computeTraced as llvmTraced } from "./llvm/shapes.js"; +import { addRecordResultEntries } from "./llvm/record-results.js"; const loc = { file: "cycles.ts", start: 0, end: 1 }; function module(): IrModule { @@ -404,6 +405,61 @@ test("a later write through any alias makes the edge mutable", () => { checkExact(record, ["record:list"]); }); +test("a result-slot entry's stores into its destination are not writes", () => { + const next: IrType = { kind: "union", unionId: "next" }; + const listModule = (): IrModule => { + const mod = module(); + mod.records = [shape("list", [next, F64])]; + mod.unions = [{ id: "next", arms: [ref("list"), { kind: "nullT" }] }]; + mod.functions.push({ + name: "cell", + params: [{ localId: "rest", name: "rest", type: next }], + locals: [], + returnType: ref("list"), + body: [ + { + kind: "return", + value: { + kind: "recordLit", + fields: [ + { name: "field0", value: { kind: "varRef", localId: "rest", type: next, loc } }, + { name: "field1", value: { kind: "numLit", value: 1, type: F64, loc } }, + ], + type: ref("list"), + loc, + }, + loc, + }, + ], + loc, + }); + return addRecordResultEntries(mod); + }; + // The entry stores the literal's fields into caller frame storage that + // nothing can point to: the list stays acyclic. + const entries = listModule(); + expect(entries.functions.map((fn) => fn.name)).toContain("%into.cell"); + checkExact(entries, []); + // The same store into the destination's local id outside an entry, and a + // store into any other binding of the shape inside one, are writes. + const store = (localId: string): IrStmt => ({ + kind: "recordSet", + obj: { kind: "varRef", localId, type: ref("list"), loc }, + shapeId: "list", + field: "field0", + value: value(next), + loc, + }); + for (const [fn, localId] of [ + ["main", "%into.dst"], + ["%into.cell", "v"], + ] as const) { + const written = listModule(); + written.functions.find((f) => f.name === fn)!.body.unshift(store(localId)); + checkExact(written, ["record:list"], ["next"]); + } +}); + test("field increments count as writes", () => { const mod = tree(); mod.functions[0]!.body.push({ diff --git a/packages/compiler/src/backend/cycle-mutability.ts b/packages/compiler/src/backend/cycle-mutability.ts index 78daa62049..7ae4517805 100644 --- a/packages/compiler/src/backend/cycle-mutability.ts +++ b/packages/compiler/src/backend/cycle-mutability.ts @@ -2,6 +2,7 @@ import type { IrExpr, IrFunction, IrModule, IrStmt, IrType } from "../ir/ir.js"; import { RUNTIME_EMITTER_CLASS, RUNTIME_STREAM_CLASSES, typeKey } from "../ir/ir.js"; import { dynamicFieldStores, type DynamicFieldStores } from "../ir/int32-slots.js"; import { everyExprChild, everyStmtChild, everyTypeChild } from "../ir/traverse.js"; +import { resultSlotStore } from "./result-slots.js"; /** Which shape fields can be written after their object escapes. * @@ -17,6 +18,10 @@ import { everyExprChild, everyStmtChild, everyTypeChild } from "../ir/traverse.j * - every `fieldSet` outside a constructor's own `this`, `fieldIncDec`, and * `recordSet` makes its (unit, field) mutable; `recordKeySet` on declared * fields and `recordKeyDelete` make the whole record mutable; + * - a result-slot entry's stores into its destination (result-slots.ts) are + * not writes: the destination is frame storage of a caller that only + * projects the value, so no object can point to it and its fields cannot + * lie on a cycle; * - a constructor's stores into its own `this` are construction-only up to * the first top-level statement in which `this` escapes (any use other * than a field store target, a field read, or the receiver of the direct @@ -296,7 +301,8 @@ export function computeCycleMutability( result.fields.add(fieldKey(unitOfClass(s.className), s.field)); break; case "recordSet": - result.fields.add(fieldKey(`record:${s.shapeId}`, s.field)); + if (!resultSlotStore(fn.name, s)) + result.fields.add(fieldKey(`record:${s.shapeId}`, s.field)); break; case "recordKeySet": if (s.overflowOnly !== true) result.units.add(`record:${s.shapeId}`); diff --git a/packages/compiler/src/backend/llvm/emit-statements.ts b/packages/compiler/src/backend/llvm/emit-statements.ts index 39ff5dcd3e..c5043aa3f4 100644 --- a/packages/compiler/src/backend/llvm/emit-statements.ts +++ b/packages/compiler/src/backend/llvm/emit-statements.ts @@ -37,7 +37,7 @@ import { InternalCompilerError } from "../../errors.js"; import { emitDenseArrayGet, emitDenseArrayPop, emitDenseArraySet } from "./dense-array-access.js"; import { emitBorrowedInput } from "./borrowed-inputs.js"; import { f64Lit, llvmCommentText, loadArrCount, sizeToDouble } from "./common.js"; -import { RESULT_DST_ID, RESULT_ENTRY_PREFIX } from "./record-results.js"; +import { resultSlotStore } from "../result-slots.js"; import { matchIntegerArrayForLoop, matchIntegerBytesForLoop, @@ -573,13 +573,7 @@ export function emitStmtBody(emitter: LlEmitter, s: IrStmt): void { ? emitter.classFieldPtr(obj.name, s.className, s.field, "compressed") : emitter.recordFieldPtr(obj.name, s.shapeId, s.field); // A result-slot entry fills zeroed caller storage, each field once. - if ( - s.kind === "recordSet" && - s.obj.kind === "varRef" && - s.obj.localId === RESULT_DST_ID && - emitter.currentFunctionName.startsWith(RESULT_ENTRY_PREFIX) - ) - emitter.initField(ptr, type, inline, v); + if (resultSlotStore(emitter.currentFunctionName, s)) emitter.initField(ptr, type, inline, v); else emitter.replaceField(ptr, type, inline, v); if ( s.kind === "fieldSet" && diff --git a/packages/compiler/src/backend/llvm/record-results.ts b/packages/compiler/src/backend/llvm/record-results.ts index 47a7983d2d..db25016cdc 100644 --- a/packages/compiler/src/backend/llvm/record-results.ts +++ b/packages/compiler/src/backend/llvm/record-results.ts @@ -12,20 +12,9 @@ import { import { dynamicFieldStores } from "../../ir/int32-slots.js"; import { everyExpr, everyStmtList, transformStmtList } from "../../ir/traverse.js"; import { InlineUnionFields } from "./inline-unions.js"; +import { RESULT_DST_ID, resultEntryName } from "../result-slots.js"; -/** Prefix of a function's result-slot entry: `%into.(...params, dst)` - * writes the function's fresh result object into `dst` and returns nothing. */ -export const RESULT_ENTRY_PREFIX = "%into."; - -export function resultEntryName(name: string): string { - return `${RESULT_ENTRY_PREFIX}${name}`; -} - -/** The local id of a result-slot entry's destination parameter. The - * caller passes zeroed frame storage, and on every path the entry stores - * each of its fields at most once, so a store into it is an - * initialization: there is no old value to release. */ -export const RESULT_DST_ID = "%into.dst"; +export { RESULT_DST_ID, RESULT_ENTRY_PREFIX, resultEntryName } from "../result-slots.js"; function distinctNames(names: readonly string[]): boolean { return new Set(names).size === names.length; diff --git a/packages/compiler/src/backend/result-slots.ts b/packages/compiler/src/backend/result-slots.ts new file mode 100644 index 0000000000..608877f06a --- /dev/null +++ b/packages/compiler/src/backend/result-slots.ts @@ -0,0 +1,29 @@ +import type { IrStmt } from "../ir/ir.js"; + +/** Prefix of a function's result-slot entry: `%into.(...params, dst)` + * writes the function's fresh result object into `dst` and returns nothing + * (llvm/record-results.ts). */ +export const RESULT_ENTRY_PREFIX = "%into."; + +export function resultEntryName(name: string): string { + return `${RESULT_ENTRY_PREFIX}${name}`; +} + +/** The local id of a result-slot entry's destination parameter. The + * caller passes zeroed frame storage, and on every path the entry stores + * each of its fields at most once, so a store into it is an + * initialization: there is no old value to release. */ +export const RESULT_DST_ID = "%into.dst"; + +/** Whether `s`, a statement of the function `fnName`, is a result-slot + * entry's store into its destination. The destination is frame storage of + * a caller that only projects the value (llvm/stack-objects.ts), so the + * store initializes a field of an object no other object can point to. */ +export function resultSlotStore(fnName: string, s: IrStmt): boolean { + return ( + s.kind === "recordSet" && + s.obj.kind === "varRef" && + s.obj.localId === RESULT_DST_ID && + fnName.startsWith(RESULT_ENTRY_PREFIX) + ); +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7261-acyclic-result-builders.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7261-acyclic-result-builders.ts.json new file mode 100644 index 0000000000..4f4afd821c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/7261-acyclic-result-builders.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/7261-acyclic-result-builders.ts" + ], + "diags": [] +} diff --git a/tests/corpus/7261-acyclic-result-builders.ts b/tests/corpus/7261-acyclic-result-builders.ts new file mode 100644 index 0000000000..b6a98fce49 --- /dev/null +++ b/tests/corpus/7261-acyclic-result-builders.ts @@ -0,0 +1,86 @@ +// Records built by functions that return object literals, as tree and list +// builders are written. The backend gives such a function a result-slot +// entry that writes the literal's fields into a caller's frame storage, and +// those stores do not make the record's fields mutable: a type no store +// changes after construction stays acyclic and needs no cycle-collector +// header. This pins what such programs print: rebuilt trees, a shared +// subtree (a DAG), a builder whose result the caller only projects (so the +// entry runs), a list longer than the runtime's teardown depth budget, and +// a record type the program writes after construction, whose rings only +// the collector frees. The sanitized lane asserts every object is freed. + +interface Node { + value: number; + left: Node | null; + right: Node | null; +} + +function leaf(value: number): Node { + return { value, left: null, right: null }; +} + +function branch(value: number, left: Node | null, right: Node | null): Node { + return { value, left, right }; +} + +function tree(depth: number, value: number): Node { + return depth === 0 ? leaf(value) : branch(value, tree(depth - 1, value * 2), tree(depth - 1, value * 2 + 1)); +} + +function sum(node: Node | null): number { + return node === null ? 0 : node.value + sum(node.left) + sum(node.right); +} + +let total = 0; +for (let generation = 0; generation < 8; generation++) total += sum(tree(8, generation + 1)); +console.log("trees", total); + +// A subtree shared by both branches is released once. +const shared = tree(3, 1); +const dag = branch(0, shared, shared); +console.log("dag", sum(dag), JSON.stringify(branch(1, leaf(2), null))); + +// Only projected: the result lives in the caller's frame, which releases +// the subtree it holds. +const top = branch(5, tree(2, 1), null); +console.log("top", top.value, sum(top.left), top.right === null); + +interface Cell { + n: number; + next: Cell | null; +} + +function cons(n: number, next: Cell | null): Cell { + return { n, next }; +} + +let list: Cell | null = null; +for (let i = 0; i < 5000; i++) list = cons(i, list); +let length = 0; +let last = -1; +for (let c = list; c !== null; c = c.next) { + length++; + last = c.n; +} +console.log("list", length, last); +list = null; + +// A record type written after construction keeps its cycle-collector +// header: these rings are garbage only the collector can free. +interface Ring { + id: number; + next: Ring | null; +} + +function ring(id: number, next: Ring | null): Ring { + return { id, next }; +} + +let ids = 0; +for (let i = 0; i < 200; i++) { + const a = ring(i, null); + const b = ring(i + 1, a); + a.next = b; + ids += a.next.id + b.next!.id; +} +console.log("rings", ids); diff --git a/tests/harness/corpus-costs/7261-acyclic-result-builders.ts.json b/tests/harness/corpus-costs/7261-acyclic-result-builders.ts.json new file mode 100644 index 0000000000..30b7c116f8 --- /dev/null +++ b/tests/harness/corpus-costs/7261-acyclic-result-builders.ts.json @@ -0,0 +1 @@ +{ "plain": 3336, "san": 4712 } From 7a5fdae1bd8fc800b76fe24619b73db07329b8cd Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 16:45:59 -0500 Subject: [PATCH 21/23] Send an http client request's head and body in one write request.end(body) on a request whose head was not sent yet wrote the head and then the body. On a socket that was already connected (a reused keep-alive connection), each write is sent at once, so the two went out as separate segments, and the server could handle the head and answer before the body arrived. Node sends the head together with the body. When the client and the server run in one program, the server's 'end' and 'close' for the request and the client's reading of the response then depended on which socket the poller reported first: corpus 5409-http-held-request-body printed the client's line before the request's 'end' and 'close' in a macOS dev build. The head and a body known at end() now go out as one write, as Node sends them (the server's response already did). --- packages/runtime/src/scr_http.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/packages/runtime/src/scr_http.c b/packages/runtime/src/scr_http.c index a5847e59b0..cb88297bff 100644 --- a/packages/runtime/src/scr_http.c +++ b/packages/runtime/src/scr_http.c @@ -4323,14 +4323,32 @@ static void scr_http_client_end_raw(ScrHttpClientReq *c, const char *data, size_ } if (!c->head_sent) { /* whole body known NOW: Content-Length framing (or none — the head - * serializer's empty-body method split) */ + * serializer's empty-body method split). Head and body go out as one + * write, as Node sends them: on a connected (reused) socket two writes + * would be two segments, and the server could answer before the body + * arrives. */ + c->hold_head = true; scr_http_client_send_head(c, (long long)len); + c->hold_head = false; if (scr_exc_pending()) return; if (c->chunked) { scr_http_client_write_raw(c, data, len); if (c->sock) scr_http_send_chunk_end(c->sock, &c->trailers); - } else if (c->sock && len > 0) { - scr_net_sock_write_native(c->sock, data, len); + } else if (c->held_head != NULL) { + char *head = c->held_head; + size_t head_len = c->held_head_len; + c->held_head = NULL; + c->held_head_len = c->held_head_cap = 0; + if (c->sock) { + if (len > 0) { + char *joined = realloc(head, head_len + len); + if (!joined) scr_http_oom(); + head = joined; + memcpy(head + head_len, data, len); + } + scr_net_sock_write_native(c->sock, head, head_len + len); + } + free(head); } } else { scr_http_client_write_raw(c, data, len); From 8bc4586b9ae864f693d0f761bd23f93a7c7f3775 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Thu, 22 Oct 2026 16:56:13 -0500 Subject: [PATCH 22/23] Select AST children by wire slot in the generated getters --- packages/compiler/native/cli.profdata.gz | Bin 1634955 -> 1634316 bytes .../src/frontend/ts7/ast-node.test.ts | 24 + .../compiler/src/frontend/ts7/ast-node.ts | 1127 +++++++++++++++-- .../compiler/src/frontend/ts7/ast-wire.ts | 4 +- scripts/generate-ts7-ast-schema.mjs | 36 +- 5 files changed, 1084 insertions(+), 107 deletions(-) diff --git a/packages/compiler/native/cli.profdata.gz b/packages/compiler/native/cli.profdata.gz index e2f344a4d7f73f6e5b70e119a45c1e9db5fdf6d3..aa0e9c36beac0cdc3528321a8a654ede3118b4b4 100644 GIT binary patch literal 1634316 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%0Aith&KGvDzCWipZ`M&bXZ;m zlO}{%nx+yCzir6xHq84dm@z3@z7_M_g!$d5o;XB{0=nB?nLqkm)hEOGALLj@5D0;w zScVItH&YC%=x&=nh3x&{TBtENH`HkP$GfGXQp0*Y8tj6t^L7HF?o+eNUj-fbz zXl+ty^j5p)=5KhzhMp9Y%E^(nQMu^vrESMDb6{FlK+D0?5WQ`QHC?QAeQn(46-bex z1xg@zk!M(R>)u`2=zQyIyWxW-^G37}$Ffn3#!I5Ak+jUBEL(PJ=rp*dA+}S_&$j-P z4Lt(w4t7(Y&2XaAo9FhqvH=XaQea76Kx7YZbMVws_xGuJ<%ATBCbxG5q3)0Lt9?g| z%KH)Xe3-#^PK=7dOGy6jlt4D}1;n=EC;f~!>*lh5V$jZ?nHe_P3;lg_JimR zwa0%7DQ2{uw$P2vW<6P$e!sdf?WYHkDT=&=sV@mr{ue}G3c+H)SwKL&d+*e-@@AyG zvsDArOIH+oi|x>{*~$NAheJ9v!wW1+0FLBD6zLcdpT#u|w_Vp}kmdE+^@8O@C5>_= ziDy+_RshM)$VzziNb0Xe_Qwe!gm~cqkIP5cIv%e5Q~lXkLW~kfh7=i=Vkn+uh#+h0 z^)D9|_!Bmg>20=NU)=fXtX_}>3*mJwo2FT(B4uUCk}|HFl+nMvy+gIEq2^S~szg_- z#o)ctuZl6Yjo&?Wotzrh0~f>7q$DvU!|*)L0~ZWDXB3bw?t$yl%$rTJ?Z)%zZ_j-I zD@$cWo?sM>W*89UUh~EXS<7N3K(W=ImRaS7_wjxZ2$3KtmS6;yqj-@)cjiJ%XzmtP zq1dW6S@_Ln5zm9sJSFfPL9;Byi+oT(0iSLzb^_~PCBsJdJbv9*PvHB&vIHSe9K$gz zLDMu^MI-(EVljQlu+iH-`mdTNyn9uSBqUYgMV^#`+^e>Y7!~+z|5UrV+Nk3#g6BWL zmjXd4l)#FNMim;!y1YQ~&HH@tiJ$(y*9_;swfTeScq4C)X~e#J52%k;3_BD8gG5!LGeTwalUTTEI5be@y7-_&W-f zkfX2F0^E@kLm>fKAyttlIG*O!VsCp#kJk91&GuD^kR#}Yq$W%r z2fZS0^qsaoS^Mp4zYZV8hz1k@6svFqLpk?ccWp`R(b7QLkH;Q&*)lVe`gf}eu}7T{ z2J(I%dAT`$FL^^ed0wU9B4B84tvbJtkr=^(+w@k`)dj_4I^Fi^n;A}L_lWOrC`nZ` zLSR)T$jjl+uNcum_uAI=IpPLCK?=N%B^3L>IDtQA z1kmxjvQs!t5?O&*p8rSfS#KsnpXmo{URuj5xt!lO0#stySx+NXrn_5DJ0Q=i#W6=5 zE=fA$ew%&zQYxz_R^S2%h0#b^<|$rA1umwj~^hZC{-^(q&i2u<}TeW(k?rWSJ8vR35oT zzgzrUAJSKCf%)JnpRv99>7%3H?+r2Z-QlTAKq+fAKEyivC)^s#s% z7$+A6(;-!bq$mwg98143;&;z)6X#SxeJ7T8up3j1%8xW?j@h)r)^b70scW7Ne;_J^ zNYgwaYaEXrh$lu_F@wLxHbV6rdw4xO5SN5J5Cwwg0jzILd1jC znT&aEFC*Js+@}|8|8}qb%kIV@hRaW5iGd_mrj&~gS8FS-=$CEa*cW4DqEk;eDorg3*a8k*$n%w#vlHv|at+#RXwTw^4x4<{aSl!1GVH z{-o;6N|2C#Ce1(|iKNd|#f*UYO2z1}*}NGaPJIJ33$ubrhID2Fw_j~Ew|j}%{yCNcvB6)66mKnN(AHw_>NnbMJH71_su|R0=n^cw&~Lj4%Gocgd%nAn zR_^M}?kTyl^1R@fau+c(eQ#2Cy#%;Y;elnvV7BWF5dTq3Ip}xwFyEu!Suvy=?tA#V zqK{pBJ^i1ay7hD*^4<-4T3t`;V(NiVAJZS0I*_@mi|I%GauOiN3hH7uM1tupTZUt7 z@3o)fl?f?Y5O|TN7=~jxGRUf9t}dK@6r)k}mMw|<;Q2oW6p847rk6xZJM6Kxc1}pd=kPaEyrN(QOK!t3sN7vPJrd# zjA>stWZOnc|2U8|&ww#&kL{ zgY-}~xlUK^kOD)+Jg<~BRPts3-~QZu>DU}k5|qbSCI;@a4&w{+FXRQL%k^}bH!xqc zbYgA95am=Pm_D;TI&tF)#g7!29xYvVha&R zGAl?Ls*i7t7;}7Md+4{Op3yJhxecD;L`o0@QWSZb4KiK&_V&X6)XKOjzO~J(_V81i zKMNO&QWQ8+qzI8DXfmjZ`L7jDnHS5qe`ix~Uq64<#CG@v>vH=%h5vcvvCauD)tBjH z8ChglLJ|pvMOWz1}yLL^{ZJ;SEGe{^5rSYOfur#y$?co#s z=JH0w{4*`1+n{|NkuKh!Y+YSy&Y83L#miCzD^N5`a|Fq8B04@mM=I^HRs3$d^@rrM zzQgd1I;p|*Bu&$WA%}X52X5a$c`Q(TgLIkTFt5u8s8 z#Nn!gDq?&L;t+>8T-{L2Uj1SFsPC;izFY%E9V^TsMI9{7(=4HCJm9*{aise-EXX2> zTOgn;?-4zPS4nLn{LU8PceV(>gU_MVAk7?@hrcs=+7l@Ut%t$47A#uGW=K6+Z@R~w>&XHG^L#mZzMt>xG5FxYo;J8DZq#Kl!*t2XNyGzR zU1V@@Y_=8oy|gYU%`qRVKW(lN@0@$^MFW*7m1TIEV@XYwPMLZ%!D-1y?EU$tfN3pexI`WsT$pc@m`$29Q+z}`;)pdGk(s@&EA7zNk2Xdi- zJ=&?h*m`XCUQ-9DljnwWG^P06Uy>5V0D?vxO+A(nIt{MLZfCb0Xxk0o#g_s>h!jcq zC8PpJQs|&PYAElkZ2$Du&G-HKUId;VG*(aqzt~dbS)8YbRx#GfFe)$F`i__b(`eyH z#7-8|><=D4J8Rva;V(;M3dl66sv0c>nQ$bUjV7;-{fSP_Bb`1C<6?;5X_6&5k>V+W z4_Y6C4Y5Ogd-nNZr%ltac1J8jFd8M1JV|mb_uMl1_tiCv?2cC4SGeYT={>ng|Hp={ zu7Q0{+UVc8(QrA2xO| ztZ4sOLhT<`=0t|3HAxed**ANgCJ$Ebm0FVT+9LfX~1#GE9DoUhjQPA$gGX>=F<5{qFeR-|Z#;CNo3gFMJp z*`sq5*qAEq><>+Q^@i);g7~zAAt_#&og%&;*k`HVdIPuC%W5Q3+(63y*mLV{tU0z` z@Bvo>&uEOQ(1Zj4O-g3Z2ab}bT(zj{WbNzTtEGL{q%of4)^)uZ(m8lyFW`1&NixVn zY19v}7sc1vw~O!0UVcY-qMj!hfz~8ml1K(EyGM=CWha%^7nT zkBl5aQ6xdpqCesZf$pcS6ACGq#@FL?Ryy0I4HN&p?i=XDFm(J6NtJSZPF~Suo|6Pt zlPRYwJ147p%U?P!JMSp+Y1+6H{YAo&*nj%9W%nBEn&BDkk_;XrDI&)Rv?8!nKX%^^ z%hAPlxQwRiX$MRrqP37+s1NEb`bE3*B1Lm9p1Usg&xY^1>m<=6m~jl&t)MtoWn_hv zDUzM{`QSsD$u&~pTC3Y6(kj#KgxesF8Xkmx3!*8}6uUKjXRVDVmnA_=zE>wt z_M6Mr?F3T~yUVidwW-s>>l7(GkOUyA6wLxur>Ihdb@j0KIJt{$d;-7!D1xCxk)lPO zBWWf`DZ^nnpgrw9eg6nm@mrkcX^|p0T4XtY1ec&KK3>;iJb{hj)Z2dTisXg+uMLm8 z6++Y)lA|a^2y!gY8|yEBsJ-=!P4nBN6`eex*_#3*R+-^shSy|Skfp7@n;!kM&3mcv z81IguZMz%L(D3)}<)kE8vx3USyUx7TJ}RY8`l7vcf(agPhN5`^aC$i&0GS7ZtgDEvlVFnUN#uxqFFhPaB9Tp!yfZgb$^k>AjGk^(BJpuT`0XLtdoH)_ znfz$@l}nHS$fTGq)j(X>bPgYqmBkKqOfC4vB$dH zaAxg+J38CGwmtPwMHF({x%;>!$e9dI4MeW${saeIq~T) z%=pP>l&&t{xKntzrku)&w%o)bUTK1T+&e#~<*;q=+%~+Uadyr14e+Q1&ZV3aX~`*P zd6aR9j^RsOC7ck!TiX>8s@6}ib6XmI^ZJB($oYu+G6obQv%D-x1o83~Ic-sA^W&uy zgO&A$ucD<*xcZ}gezC-iv9909Pm3AzJOT6G<)Vlk>3qlG@&KX4+&MyU3%L27VCTL# zwX5oHb%RgzVwx3*G%1iGDabNA>X12X8r;!)>?0R^|J1u38;4=dXs0W;XP#T}yCU)5dHT=BjLi9K(n}CBZIBeL z=^lH^uqocHw^t1o#gwGZn1v(Xk{eaJ*#f!VDYo#m87$vwnrLL7PrL#( zV1&@TpBJck3UG=N&l9A|5DHshIQhr2`OmzWzdIQfF3R@OwW^}O!$GV9J>WRR>GsE` zHvVtb;P8Qc2v$=mnWkw)MIC8QM^Y0eUyLti+YjIT`0!cZ!zz!3LX14i2#QFnK%l^a zzkb-7Pf_+-6@2K#n(N2S!EF21_RQUF`?d{nNCoJAu`K881k1XK#>y++s`@E9k z%SBJEMi|~L*^tMXXJ0hhK{ePI!haX4LP9Gn!}AQOs*)(39%nsB?MT91%J>ZOM&K*s z??wQ%LOYeQoKB|5WDWD|J8KTK?--BOOp*jy<^@fbG)_Q0A}`d>rKUfpMub`C*|!ZH zw7cJzVTm9?7D!4V7>VRWbUE$aQdsp94;QA_>npWWhAAK)EP8m%{>uFE!aLO9!h4@}IrnKjbG5P?Nky9}$b z0>=ZR=eTD7lfWK=OVoW)ToLCAVSaG{nQA{Jpg8Xn>?; zg$5B~um$$5H`Z)@|NMq{QGG%D^$C7M?tz+qVoh@1R6F7Akq$U{Es@lOd5$xMH~KEp z_b(Qd@Mvz|Qzw0Ww_#0!d5;o~;TewSHBOKzj>W}#?NT)`HJL)^@nZ02?4Jz(?ZcKF z#OgU!a7deBoc;V(2*B$E*)HE;ASs!CwbsUqloNA?RjTq-gz^?x)d6#0zO?XoyTH_h zV5K6;t6g|Jd)6T4+sJkmvrN!>nnw9OI=<1iziEWyQCf($Kjqa92#;6-(^&O~suBME zre#DUu?DNb{=)UQtcnb?+l3ytN)e88q+;IBb^5!lBf9;Kd%vxtZ2KB*7Y=Y*n~-2X zV2-SPUA6G#e^j%4_En_NwSpZ`#=5>oVx-YCtdze$UrzTO9pv(TKTNn zRsPU-;QcKEE1IWc3V3gaEaJPLqBhX8eAgdc@)D4 zAGksY$}cOZp3<(<1Z2M^VDM*I_d#lm-@Dr2U1a?CnWLK@c)p|M9K0?3cYm9L84+^` zBHV0x(f-!`ttxd{1A{v}5ljVUQ>@>lVB(N0k1ySm=k`4^=%X{6Zg@HcvMYNGu#UNV z;ri@0JP@yU)v?Uk`vTwJqQ~Vqb6@B@EDt5q5=<}Io9&-6EiDbww1+}pCTm%eufN}G ziYD@ap(#q>)z@FU<{aIiX(d+wbjRZISrVSRBl{iq-rgwN1>ZONZcwAx^zU$5`EDs# zKH49gF2hUqtWEW55VtfB=A;7I9Jl24dL}qYl~gqfh>}8zsLf#w13n?a^s@cdxgCC( zd=_#>ABQyQP*_D&cu5o}N!)YYmTz2lv^A|S<#<@GaujQckJCjR*Z4R^myeI{l?m_+ zc-g*de?kizAL)6+%PPh20?z|gMum9Q49}aj_8vWl**5nM@6SSGNmgM*QJ`h1i*-e> zlI9e4B*oRW)_(NavwJW~W(4O=;F@W> zGhWSYu&daO>1+1_+2OcIpSdd3m;TXf{aTmr0)0i%08`A zJ`7K>WO2Q{Z~i>K1G!Pt(vfBfOjUX__r)|^nm-vu$55tg4&%5pCCb7!M{#E-kCU*8aG zg1|5oph!-VMN&nbqe7S+G1}T<@BQMKUYjVmz(V`};s^;yD#0lN!Jd(i*L<&TzamRI z7*?`TsZr-v`}!si)UQ?(kDmmAq(zY?Xr3o2fs5WH@pk)CLi~7v8+P+pNPdn193x18 z*Em`n2qsnK|C(;u7$=G15QjKiVE|*Mzk+#gLVmYlo|_E5H+uhKowH`s4tw@PE3eTi zwJyP@m_qvY=Lu&|ms`r}=>l0Q*1NwMThp8N>&|C%`sq~)&)o%EZWP3k7?77O1Md)@ z#k~8g6o_3Lu9>8FzvM06ZU;{L4hY=V{51rP?ULICKZt)6m{W09bF54 z-H>`qIn6{xDTDmx3je$H3fa-9bQ|`IDyQ-M-4$5R-x$$Dzl%IB!_9#=3aIpdJhBkS zB!nlX(~*2jvY`5|O(# zQsM}XQD_B39^++~T{)AwB+(qkY<0Ypl?R-DAB~hIv#Kmpv=ZdIxH>Q8wy^QcCR5@6j8F zA9Y#f93&lW3Z3>wQXGs%^1aJ>@@7;}kU?~Oj9J$A?W3l5Za#k_bX-zWI9zzk=@gmNPof@3M3BWU%#_1)ilK&gUVVN-13 z^G0CwezfJG5Ut-}-1o)f|L#Gf%Z3l@D3cKu8Hp0hVB_a$L(pJ{*-^W)YR;RxkA-z}M^Y-o zb2LY4DucSYTZK&JDvME-U)vAup7pqAK{GtVSJGTcQ8bljNnTbIA@kca7fNz|y~-%T zDsI%b_Kl+^KXPnVxbUAWNlAjH$O^|uX!y_d+X|bqXmMZ~T+?y;=(V;jJ10UH4Va61 z&6VYMpec|PMFL5p1(I;r?_1feObrUpDVNe&Po&>{9O3Uq?+w8?foL7&cX(X>y?x5A zdlrow1Upu>SuiO_3tXXOcZkpHa%T*ZRMq9q@QZe9O>Xvcql335+;*kNBja#YLiZ@2 zmp9aoQ8`?M?l4dlC6(L3ESsnOME zZ4BN`h_F6fKEZ&0>~2s_q|YN&oq^EB;G9V?=oe0f16My2<8!An@_izbmX$weFzfYF zJ5L=k?k8c;{<8M#N~1I4bW_EECElJm#32rGh{II~#aehj+q2WAb!z+^)FKUGHknP5 ztTS73XJmmw<>&!mg8h?`)9b8WPz4@bm8wQo;m`KBSGey!ycDWN%?PU+rSd?NSeB+) zg1fQZTV$tS>n20P9j#vY8qwd4-j5YLS-W)aNBUj8C~5Q$6G~Su&PQN^>6Crv_{XcK z*x-PU3HI;p_oGAsR+bo*V=2(;{FE8jew}9Br+<;8FPop{6{cJDx;r)sT!auV=xL_T zce|{CY+Dz-1#`^Nk<4fK)HXFibWrzBiu{x>hrQDJ}(sl8zPKZ z)$2s)=M*A;>C!*+d+@N3qa5#8m*3PIo$Y`FxsQh5I}GlrXRIxJ?f8V?`F#j}?_acbnR%Byz zM)Kbx^Ry7j4@2@ilIM`T70IKnuKz;vCz1T;NdA2!{~nTm8_91+*P%fkb-TO>$=|D| zeRnl^`sAbYa-jdeQ+DrfyDKHKFm!5(P}_)?5z?8S36ycbn=UDt0NVLD)uTsi{Lp6m zszex-2PJ2#mT@KF7240*TW;aq2Vl!^mGJY4I2P4tPdHW~p`u0iw1@6VxA^jEleYOHZ<2gy8dZ|sa zsxPjdf*kWfbPZ&sp;w^6db$e14u{P}Xu0tG)PJ}}fBv(c=k?bfzyy!zhFJp;|Nf^aUeuHMIoNwF8m^>q|oL`~!MA7Aen$U~Bk&E9Cpx$aj?uuru0^ z%XR#5*FpRBG+AH7H<<(Z5I8TWcOuwL&t*El8oddghZp+l;G&Md&SIc@4@Xp#*87MSweJn^?IfJ z9$6q8xP5+~e<0VHA;4s?9jS&>$bx56-43v550zW^t6eN7~VwM z{N_~}tQXJjSR8%s{^%XczIu3e$L}JMVF{TfNkUTvl(jk92)7PwjzI^9HJ^5%9wJ5v zESus4zY`5r5rDY<}cF}+O2a}wZhlsk;ghUuP3{Q+vjzGTqmip62sGqK$7BTFFn7> zH8R%$D{g~?tVR6*6jz+)xV=TEG1or=w^5h&K^14SG*xJ%-7U|R<#W0Fd(^xv;5X79 zpZ;|JE&E0@dR~5E9UJ zj8ac&$U03hSpRW|LwUeEn0!w?g+5;!Ab1z9XGm37LGXP7Ql6!hL_i$k5KBC~6Iq`L z$nzqm14GAH47lky#1^iJ4?#$P_;-5=X2}%d?#6`RZKH99>wK$$lrRo)D9?3`gR00n z#r>Xw;Y$;c_t4+3*Xfy#dj4>P?XIYsqK5G$5{GhJk5EP%tur#*Ih`1via1;b(7_z~ zJct#vyhQqm8s|E$@_9$k)9MvG503cOi;qJbu6nrI?zopA9ezB<{m4bypM&WagfmgLKNrb2!|)YG?L@~xHjp=<_u~za zdSoPD-GF{@M7WM7V)&@U2>JhkQI0R{_ZWlzt^*h#Z1W9)oyuSnUUgZeq z8IJ3va&J&pxjJrs#zaZyO^lLWE-y$dXL>Z!P$P*k+E3B)KM55)-j^z*RnWL!EdKUt z{tCvb0OssNsN+Xo{3oAjm4JW1p9ZE4rRz zbBE1`>US#&rCMBcfCC?ow}+%;I%QI$X^B=8fzlc_eSiHgcOSQ){PjSL0BK+;1xt~B zx3rY=vowUfAhfc7eaGLMp4z-=Ha3bPO>rVA2%JdK49y8N8bxukZh7`GcB&gXe#jrP z_5PFff~zQDPayMv=K-y1tQ-`-9on*FVob&pOpP4ve+PAXOob-uA?yfroqmRK_VerX z1Futdxz$0E&j-Bjp^`TP_@4OW)b83PTt-zlhi5Bc{f!*owEeyT*$|q25cu$@ETPG) zKyrctIO+5_>p^NqQsc`U8<=DKJ#Muon3_1Qb+qg-A{~y{$Dy}&t|uEfC014`nxZ9z zq)%s!{qWZJ##nGpZBrs_X^MfoC#94lfYZytjYJd2_9Yvh>o~7Dez_M$uXIaZuV;dj z0UGbO5>^Fi-!_L|89TKO4p)#A%aR1oGJ-%6tcaqD zyA4l;<_=~|KW^wsh>dy|*H9b?lxIZ&h@3==JU`>vHQ%3FU9%EYSaSCWEIQX3K3`mQ zOUE*5%*yPY@YHxc0W+j}Ku}c!3?Y()z>(MW-^tI+d&R7qQkn)tsUDJm%y2@C_aQ8g zjIf-}W!&doBb3sVRSH?<632Uv7~{!E+hdNf-r~jI%5h)IC-#k63IiQ4F^AZ9il|CJ z04l9=JakJ_Z^9c3s25gS;EI349GIF+q4SyMz~-Xn<>Qb%K=KWcJgQJt-2lNFInP0t zR%L^HszE;4VCg$B1U4>jGss(u#)mWAeBe=QCX=r}{syr9VM5W_h8WM}93BsmN8 zbb%~27mY2x2bn}8Y9CK^wsU;-#<89M-T)i5J3O+b2vJ~Vz!N|tj<(!Z<73`r`Jevj z+3J-{afrj^0>wNF9w>6ShDQnt<@Cys~ZPca4I(U&4nl z@67dkFB|6Zs=a}vf*_w|ov!ut^%B&k)dkI=YP$@woc}1nEkLN8G$BxV`s&eX$ z=77|MJP)oi-LbAmO8zg-My5bHLJ0m`1RTY&sz}k2l(=Pe#)~^%ONPz~)ca=D#eK@x#Vath6p;OqZ}PA%!7W81x< z)8LwJb`0Ih^|GXd*si(ycI}YIsgeYEK~sUqG~GI4nO}$ow=2}mu5ZBg6<0abv69<& z!@~7&yAHx{SD9i&nN&nxmE}fnwR>*RPy)Ew^U zp44zm;=6d^FelKIzzBlKk%GVmE#zO;6&Cnb0&cEHI(|-HwxHu}@Z6jc^4ugCkpqgN zF@i+yJ0pYk1L+X%c}3~Y zn9Hdg+$ktKR%JC1JEeHaftfx<7rutuN_-$b1Z6i|5^nhNVk?-;M5K`p2>kHGjkmtHb zIMZwx+u*anJu@xBowgZsVyEZ>y|j5D!#1R6LO}j5{od@>?+Y8&Prq1z&v5|DDJ|d+ zGPh&g{CiLCUICrb4+=)3kl%*hw|h#8qylFK@cGf|ATLl|isSX5K(o(L3D6#z#wEQ7LnkLzDLbhNbB z7MKsNa-t)9Q|Dd#%(a7=e6Nz_aRaB9lt_*j0MARbh%)ytrr`?CcTBClrS3p2yhlKa z1-v8yAZw(CmTke#$Q=%@vZ<}}t$M*%UIE_r6oDXBfdMMJ`Myev=8imXfnwRCNZCgt zUT=3fr0K)Azq=Jr-;n~xumVAo48t)bi!Qjm`cMNiu8OG+s#D$mZJJ~KYyz5BMM97% zi34Yv4xT;cpG`%6HaEcoBjO(2<9PA=Cr{2AhiAPwLZnEM=LLU43uuoH>2-I&Rx#ai z_uz4zsP7`U?B^tcXH}J>1dcYk>__EkXx<2n-jB9C6uKa3S<5j-+V?t`v@^-yPsCzF zmSt&?C0L&2cwP*mt|#jIc`$Y=XE^d|Ja*!aTbkn~uzFwvf^zoD>Ynd*O0sL9rsV?P zg$ox3&RjLf25Wnxw$a+0<#_0mXMX#*YFcn@MNti0KBqvS>Mv6;?q-XNp6#gZ-rM;6 zbnGq@35t_cmXQ;w}| z-(1rv?K+4^tQZuJjUWRiN{Vlg9!92{l#zF$$NLShA*;;3Oh#sCd~w7SMj6PljmCYb z!GVH8OC*gHO8ecV2C;5`B8DZaXu!?44NG<{a4Z^n{@z738ir@7C0SuaS`+~3%+2yl zI5}e0=OyoB#J{Xz)8KlSI*vcocD3>dmbxTK5-2p_6`Ced>T;DOy5TUJo^|y8Flpq` z#UUgICDaELQl%JzBt?ouV|qrL)Phdn>Q09s%q(RmeDx@Alz8`RZ=~h))Z$pG~Qc~QgUoajs z5b^!)i>}<(mnhacjhTptE^}8Tr+gJtPd{DhqGlb_6$Q^-VL{LCt!=s@!DEX}Io8YE zMdRBs##f!LFxLl0ht88V!uFugadZqy$3@yd zSRRfJnov&X=G#|@3ph9qXn!tuy5hO3Bp58*m+1VJb$!C`-!@+z_==oUQZ7`XMdoBQX%eVVDKffwnF8N}go zf#MB1tp41&bzguwOd$pV@ z3JSj5wGyuA7ad=2Uhg&3y=k)w^Jx$PSeqBd7eRTf=iTd|bbUX%aLSgyG^xs=11=bHo^&HY3 zBfJaygQ_rRn*&qy{TGq2UBfKflAR$rT z8=j{N(_Q-5j&Be+AP{z$F0bzteJ%W`e-DTBDSb^&wqM-$F7U;#(Ei41{v&N4tiK9ooN?d5=MZj=Qeb+egxDrZDJZ^FD{==N=VUM>!lR2?XJU1B!9;TU_8_+rA$upVk8NfKq2kr`T1 zQ4ck!KZgC7qo!D_y~~kVx7A;1eWASoA=(9+1c6I+1VM_aBcjNdul{OG(|XF{&bJurGn3Q&1>^&0o=kPjd*>F=hysE zN}b0?`ySaI-Ju~*O9Dyon!+i7+er*7=+JPk?jU6A^q@QbJ5B`i-|4o|z4U-aub*>- z1HFftUdXGTdsEIH zuT^csil|5byexB+AP6eY%IJ~R8>x{CPB49((rnU$O~+M)qq02Wr~p!Kg*2|TAsgh+~{z@u1d z(J%5v-;Y!7x|N)rJ_0IgnnrePbUC<=s`4ZNDydSWx;4;q(I3s;PpfN+(A)yhC{~xv z(Z4S?lu@~OH^&E3#)%`U*1s8IxJDEVGb*Q03Il*BP+NLVX|s35q7>*dGgfqn!a{N> zA*NCZeTT>B!IazN3z^Jh=q@EI0-q-ZXO1f{wx8s2Dcyia0hj+K07uE1NT@QS^EXyo(Ifi#iKR1-&8EXC+~|Kgdp?P0z6k;+0Y%~!ndQ*=hEuG?P`H`u#`#`R zp{&ZqQ^#j1gIcb!R{k@poI~cyc8sKH6o<+=93~B4U%p7GJ?G%&3=<5X^Io`VStd;} zPIqqTxgLQ)R>utB3G@LuHAZhge#icda*Om2Ro#@eIntpNj9LQCk7^kDza_@@Be8_k zAF;gmCKfR*ZFNUt41APU-crW>x>D3z23$Ma>4IXz7bz>h{QlFlqtFsRD||64Xo)Wg zq{K)JuMhwX?vgXCQ&GmTWN5d_y(pO5i)V9=bkPBAHC`M33 zp5au0Zc(dY>E=v|yZigI=e-+&Zt{y3WrC$dQDrz;V7))jDd;WPQp8zfHl0mr@TO_m z%X8tpnVuMx#nH5?ii#`(juCw=o=hQx6_$DWr!BA3)uX~SrVOtV=X(z)|F`W7m<+fc zAz!t7F6BT)^5B`NweYIlT;(dm3k1Px8Y{^k_P^CpP@B83klNgHDWgxO|0*7@6~6f{ zP$R8Mf<|$o#B#i)e2Y!B{=S$5E0T5BkMLI0xW+iv{9TH5cH2(YBog1dOp%`s&612vzV^*++X{*hicX+Stc4|xpHmuB znMBtq_3?AU2NY+HOAU;5(xfN~sv=7w!7u)Fz>%@`Drs$)3-w2cS(zH7={EykfrD#=gl3du0 zEi0A?ELQ8NFXTfnHVhw`i1*}y1ZYK7MU7F>U<429KgwY%OR&B;_~+eEHLDYjy!@>l z5J;Y935H-eaQV!)%BhBQ?j%b_mK)r%gZn?f9X9I>`?#lD649=y35>uABEbkE!-Pez zTbUROuMTV4cYBBBT&j+%LL_L0r+A9vXp#)8AiGU4U17sjP|^C?@!xtiERT<8!V8or zFbvIbG(|FDA%XtT=hPu=A1YhB?$~nt!p`VNqXfayf*_HiB&mTr=Oy}k_)^OwtL;mA z`jKus{FP3a-Slg+lPZVuYD!nUFnUb#MLIej*D0OWpTDkukdqW^$g5iaShn${qbDJ{ zjznU1JWmr82{=-csChR(w`*hT@hNZsq1*oMNEJPi|7#(6^nW|@za3L9`n==>zG~KY zE?U}rG#|^11(6j9j^HVVrwAhKj%F7f*&UN2*HFz`k!YJU@d7@u4+}J!6G>jxz)gFH z+*wep>Z+#$^|W2gWvsUKP5#|gu`F@!EO7WQE4)L}gLuEv z@r_d(#8Skn@FYoJBLliwTsfVi{FEGD{gq;rU)1vUVC);5dO0=Y#9z%K;(c)`ZLw2} z_+6DEwx>c7>!S;aCzRe2W5^t34b@9|ywLs%MXaxVjOStz%T0`Pd{Rq^ev1lqOQ^qB zDpWFEop4{X_}&}#nZ6m1u^`pd_lEV;LK)ptZ|J*Oy}k$Z1-hOtXF%%$xPEoi^&x$9 zQJNK^(+A{Va9s&hjQsw&8$;!=tnQKDga404)+;m~`~AA$0^?l`(c5t_PQDDwtB_bS z^C2+?eqcLCC@{_t{%twriTLwN2xcXsw0bh>}xbw1@6U+&r zJ5&*2Fg%jK2ieeWLh4z9=S?%KgKf!_f^r zX&z`mWEoPU&?9Rzw&2~vCstekW(2DRzplP-olP+WLkKJb1V+7QK=P`BXZ^88K3`+s z*g9kO*S{=j1^LR6@L8E_QpyS(pcsuMB;|&i9vsr=L{jR|GRAtNtAjYM7zwWi25*K0 zikk~ftqjUR4;o-muZ>hIf7A`p6Tyo96sDFsV-(W?8f}x6S@_}91r;P zbY9}sipyr!W7YztYz;Do*?uV8HbV z1&xBNA-kzI)_3OaNLX_mN(+yhBJ6+#$_X-Efo|D;p!Sxs27T(#K>ndN!{hYb(wD!$8v#&9&r0gBIc8Ami4 z>b`4n(~%CS;rmkm3N|nmsZZ9^YWk7j1>LtK)O-D{AI(0k?;;ZQt2cg(X(%iwFD-)s zDYyq(4uHxKGq7{vCwEq5M_<#1=Xnnf57LRQ&8jemu?EpKZE4m$R1`KlAni^=RxuS$=`0->tOHJX5}uOrw=H>|6DfulSwbL1mOw9@wRtU= z-e-wCOF8R-lr=3Xc7}JSdsGbH%QA!*bg`H2@n-=gFhp`^gW;baI+S$j>vD|^pJxV? zA>^rL^pr=Q*T!h0%$RZt3-OYB%VPGgq~0rOyqn|1M``1?`G1VxBn+Kd%6NRt*Et_3 zE&4KDWAnGL`1!BfmwJuRspUGKr`H;|;vCNg#pE|=`Q|Mf$8x2d zhIt>Ix3MnZ#wzDZhgkhfy3W^G0}L=A-u zuM$?app@DPDX>1W;-cEigi`Kb{}LL{#xb7PNHe%kaUlCDvnaKfaed#X#>a1GT&2Dq z*rbx>zp>!KGQv~kINwVvA|FOSd&(C5{ktn%S(5gBMQjM<>#^1^OANWBq{vOa#`v+n zgw|Kfb%KYof_UW__+DW(n;#$_v@hfYiB(@?L|(%2$98Ga*S|mG>{vGD|9A8Sd=7?x z)GcLtvXl~i`7!09=yDWuexi6yE@XLQ43W1~0M6IjF&Y4iX@K>S>D&7{e#2UM&@91I zBu5GqK?y9upjIB|6GKz9iUHR5THgQW!&E%MnJ7x-DV`Q-MFD7Vri3>mZw_()qt9c# zS5$a!ytz!u#XII5VU^s?zE)G9)!JB77>08_)Y2rcu@WJ09QS8RtGPLYd1#Jia_c7s zYi#kgttrwL_`BAc#sd-@Ec5NUJKZEdF$W(0;Ye zVnLKxCae-`jCESCvz@+}8a3=YFAF3ikR(m0G#d6j6~h%%u~n+poblz`zc&VN8^s6= z#qb;bj zvtMj}JI`H016$-2!Z2hAEeNYFdKk!3SVeKB}^P5h8&(oUCuU_c6h+$%|FKmz{8 z&=kc@hSfgj$;TSL)&Nl=U3Nr$IcS8gxD<2!P-pn0%#I$(J<0F#qwynP1Pn9{AC0lr zMLRZ6f1v!0crKPna?E8E5%d9y>ZZ?<)N&Qz$pS1w-0Aq77q9h@~X_ z$E#667M2*o!ra!U+b!RD^J{RC5c1I*q;-g4Ck*y8a8jo1b>G?I_ggo#U7iMsyN2V& zi0RTcL2BHa8C(z@=Rz;!Ew+Y!58()M@zIhC1^Dkqghgy~gyv&C&qkilLY@ytW~GV{ z=vE|u*c4y=7L&)CaMQcDwwM`x(V#Sm6nT(SHK8TJu?A zwvM{t*Uy_H*5DhfhUOnb@^z7XOJpToi0HiLA^BcN{sts(NAg_|H>M{L<;o*SzR4Am zU$OSpG3OKN-M3HQwA_$=#Bs)4KXE3++iOji4tf5jW-!0uQkB3RExP38*Js@|e{Ou4Eb^RQ06)1}`Jr$!GW zM{uGnGXhJhvWy0>iY0L8Pw?BV=iVH-FrgM!PGbmCU>Sno2$~^9o=4@hen*0pJ%|aK za=SJ2%lk&(aU(ux3JoNQ1r$rDG8#1HL7hW&M|RD4QP*$1SZ;WuISt_jjR;|^3Wj~s zNM6$vQI!;lT{B_5tzbB&$#JS^@Qn#rd$sTI#s6kN3AIPKgi7!%K@+qnh^mN6s1F=T ziI~RT@MK%7{c!Ni6JOng$WJe86%Gt}^Ws=9KPV#ii_9z{5mn`7x z0o+-@H~8KsYW?xmvc#!n+z~ivHH-OwaqCCT*J>5AoGQp+K?O`ZYZtQI6y&?wm~yHh zgb^#ALAg>M*Z<0x<9Y{6A?d83z#Z-2aiaC(K1a?g3)|usWEj{~r)-xy;PMO%_<)p&uGooj@;tL?igj}r-=;>7z!k1TT7-?ZnCnv2 z;}1xlKo{2pm*4Aa?V_pO=G(Wo&a9O1bO|fu%KC7$`c*=Y^~$(D^A(PN3nsl$EkJlQ#8xRUfMth8YUIVZRv#{K6&Q~-<;(z9^SgMz zhu?L`gFniVih}%^y=KDC`SqY~5tz$l#GWe7f7e)w?lL$g!0Y&35 zayBV6MgK1;XlE|o`#6l;Z~cA$V^bz(!AoBe^ol;9ICETTV62muWKQ8(nUFMU@uvfh zjI~!ugOq2Flj`rc-rZ09?94X}@dHqhAt;1I@e(f)giJMR-u>8j(~gykr5l)amBsTh zn-*9*{`z9}%&+mLY9cF86vNO2Pm2r}W~%0VJ(#{*5m&`RYd_b!OOKCs36>yTGaAcj(D)*cNo^Rj`3321_koDjLO~{2GwF#e`8UBL8B+D?)Ub)BFz!#*N z-XJj6tM&$&GVuA6X7_F$Y3;^yg-5M-+czxhHY5T8xK*E%7jmzB1D{KByCwtYSjmqP zK$aONc|2)df8$$iKb!%J?iY!+R8EsAR#E_v7-?JA_g9bpusnK5R3!#6;|B0aYn79= zhAwGcBYfTQ=?0=cf)!{&)M!#5WYj9O4<-%AA~cPOI*kO4&}dpw37#fUEI$81BTUiH zS>M}q?m&Y<^}~zKH)q|bZQT>i)$%l~Q$>PakU8>TNdhWrekmrN7 z_C8e(*C%G++2!iN6znplb4{oDN0DX#Bf{;ym^ME8#{mng%q)@_R0tC8J{pV|JWdbM z`5W&i55gt$^@%wjVR+UOX;yL&k`jTFFv=zD+9P16MlSm+mG4>w-=30Ca0QAl7$Ne(*y&RU5d>nC$dMmV?>Vn_wA`-`DcvNwk775$NQmjM3&0p&#gbR&cwLW}1gc^=u(zg_} z$^5i8KUddVKhw}f%sa|d|Iz`qJP^7q4TeP5b%>J4n;FWRAf{Zp3%3I9db{8|Rk^!M z9aV9}vBq0{$V5!n$zQx-HXKs8#@}iHt?oj`{%}NM4>1?MeV)p`%#UzO7_w#Z^DuK{aD*R1o+`MHSA{l0paT^_od-;${| zRFm*nDH_(9HJ!PifMxA1Z~+-`hosT8$enI#mOV!i{8if@*kQtCJC?$bauv((bNg%F z_`K|l{MEgKwsW=InvNL_Oc53@Vckv3WYL&~uyMT2Umu`|7K0tdDm|P<`SK3Z34U@4 z^kx#;NLA z)jjC9$!n9({aG-w!+U3-(odxfv7g#=Rw~Xn4Yb#|bToK=HqZ~T@)PhAZtGlMWo*f} ziX;g{b+_|~h$g1#)Fee{@n zcUD=Syj3h(N^IL;iH(O||06CJ!`$?V`{fH1I_P0h-}fON_>0yHi)S+zIw;hK_WH@R z$Od`$Syh!Z;id5fz`y%~_Xc2{&&-_oG|0c+k31g3KOR$07Tu!&x9Mz7-cH{AVEU?^*Kq?{3d46|{1eaNGtXQBgHI^qK=V)7k>Hg`r>yt9{HShiL%O zDa(H=9n#uXLaREVZFj5r#NhfT-nP1X<9U+lXU&rR8z1T>H>i zFx&_j|J{XQ;VNoJwE8s83jlYSvz2m3VZdgRzy?*>Bj_ZqJb7p)ruucf^BUu`eM^xw z1v>Q!Xrr3Sl(NfU=&A(B8>haOc};T4156YdyPIfN$dbk$KP4kE;GLQ2rndQidGS;X zOGkYNJ*Na#zww<P345ETuV9~mHN9G| z-%HyC6ev-n3P5J-j=rabmt5CcXg=8KU;29{0xjAN8-js)G~aDI*?Tm~#-A51H*!5!wCrJyx#~72y^+nn4TqWg1kCM94 zQOST>+623sI$k|uX3ayx*@HlaN(6FiR!nzV@}=LMJ!WiB^bF)as`X? zvpgGL>&urGpWl`<+A}O(R4yztAJ9?P#cRO+4{Zv{N$fnX;erd{ zgB$htI?s}5{{*gi=T-g##++{1VuNusihLAE1tTqaVP-Qs3sKb+T4%wpJ+*AR(~R0r zjc%0F1@a&C*`>LHJHSqAkS~&J5Z#v;lbMI99EgHHG`jZr<~~a2DZLgjrh3{*7XFD& zQQ0KU1eKKtMZbF=$B$MFwvv>z?vrrG!hG`oDb;Gc*4FY$T3UWuqM^xF<5flmj$J?f9 z{_Ze?{HoP-0!ATkXNMXq_z_iBSP(@ix|r-%;Yc7=-J04|>#w8qG_H3fI}CWewI?&0 zY-EsfMJf#WQf*Nqo-&n>PYdK4n_MtH?@@y6Vipi&Qbwz21kCl>zugu~b~8O&Z^GzG z@Bs2@tJ^&RYBuT=P-qZ6B^^1#b zD}K}2jc|`*kP?@u2y{>W+e8j zDIaKyN(QZ*((j#M+4^m2xA!{ZT5ulqp&mvBmKjS+tGoHZ5!#b?^-cGlBx{OiTWG0z zG(bj1CMEdlVY_ja+7aW2)E1WS7Nwu!dgiu9Xp%|p=n~D43OgH9r=n0}>a1iN?LEEL zj+N73;6z}nMq^UPD=N^8i+h&>Sqi{7#O`;y%5_?GJsh-})Z<%y(4?e2sMZbaGs;#kID0Y`?tm*{~;2pvl96NzZk}!){BRr3(aDFOG5&ZFbfHyXLOzX<5Zoi$__=6yba{IRu|~C;#4M=53B- zeqm>@M%bGAv~}#O?OmN@lu?9P1d^p-pt>`$JYJeks@d6}14Z_+o749lMpfD6qY$Lo zf@x4nBlAJs*d){E@2V}Wa-5Hm+u(RhC;q5d z3GS{apY#1;XXZjWMEubQ0v-*?D0>nBUMD9WLOI-y>y%a(>%@AL2Kp6NTwhZ-EMtOz z@MFh1DD>M5`n@Ff1)gKB>mObMbdYL_2=oY(B6QEK@DKbR1fDp^GaIwLRo6F6_!dVK4tiD8=EZ}*(Pzk?l&Zj@9$QD$njd|IV&HXb-eYt}_tk0JG59Y6mvFx$7))ev-di9}MhZ)mGLt;*7P=nk_FbU1 z^zsrlM9&?hYmcF}@QrSeO?togy+$FrPhZaGkpF0w@9j{JXGZ}+z8a5)r7y7B{uA%} zw-qLwbLZW@=+YJ0fQ9i$q-q0;XU0>fXpVvf8LxM^3B#Hd?p|3u$Kx#Z{aj7Wac|Z6 z%TASPk7|S6XRZUJ|K1+R|Kk!^4Xy;RL5cPjyxn}C_3Z%@ydVqXw6df3n0dCFNt~V0 z3awb|AEl)@Cive9je9SbkaBJg6s2LL+*DehtsbJQ<;8!48E__Qz`C3L!-utwB9U3+ zPtTs>B6=YeM7#SZp3iJ6b_8lwk_Q+6O*(_$+-Ve`l<=Du<;(e>R`Tl5uC^M-MMmD1 zMFxRH?#IK6|EXi_>|z$O%{2JY|5(SX;G}~UOEk0VJX&vUz{lRl%Fb0Wmg(9GKs(sf zGlbuE4~HXbQk|#12PtgZCY*hF-B#>hqzBklpx2$@8%o8cV!3hKHww7EPK0|f#u9-T zP{Iab(uk&bu}7}LaMLshQxFTnkc^B;#jVsK^A!P zC9+VuW@@!CSLFA$wGa~^Cgs&>9XWjDcG>SU~rX0A_fN$O$3uf=CiH2YJhHSCn4YV6Sm+3&KMhp z;w^tadWZ7p?Cs_re3>koV;-UDoBN6w@q?SlG8M&<2j@--#?C_$#srASEJW7s`9J54 z3p>LZxgdxet-U{Kq9+-NLRcNEZ95>i6BrZ)M*Lj)_%rh63rZWh_Z|*8PE;~D;>o|I zvPrCxcC5%4V)r)cA*fA}(lg?kc!>3RlwJtxcCWL@BdstlAA%4vgm!YilcON@k~cVT zpYyfSJqLf+$+1=j=onh8BQh4fygKOwe_-uDzeXgt*!jX-LX_a z81B6|xtC7qeCf_2{7B)Kv45B-^9xvGU;Id+G}^@bfBZA+9JRiJg22HMXc$)Ec^p&_ zQ*r-W7yf5)_}>@dEYNKuj~crThXkGVng|Jd$cvJDy9As@_fWOA5Ae!M@_Q*9jM zO^CH_RsH9fRbkkd8h#4NCV5%kq+T$Ton;5@sx$S*5j;E*xkGjR*ZnX5j+YD=DfLqI zq$67Kojkf5Xy0w=KhE1aBDK0HAaNP?V&4f~La6;j)^M7{V=EGOX^H&SNfE_Ai2r!3 z`Uli4w*mizg>M;CMdnJur;_}D5Q`}uEy0R3d_r0;^We?KL(TG7MWR;lGJBbq@D>~( z43-Q3olAsrQc?9igCQqvt`#=x-o3G1U3S+2_>4q+*xprs5EkP9&H^CI%fj8k{wkB# zc@{6$V4I0%WvRi2bP)YcUkReBCZmQwcmG&0)q1IolHHkYT;VF=j_B}Z{S&*V&_=iC zk@wirpixDRP#UUYn!Y#+K7i74SI0JG0NB(6vb-Ww7HZmik*?DT80z!UY z3r$HF8>gjj82)gvWBz?B zAXvFU<9mywpU$5=b3EmAS5rz8TpUFJj}^cxYzbIT_s}i(m&@I9zy}`iu=x*YYu_xD6B4(B@W;E3s2x5=Y)UZ zC$W5qK{@6B0X)R&7Yr61Y&n;|R##cri51M@ZS90AiL~x`OAEYrxilyWX0m9_cp&qQ zAo^m0rRFWd>xsBrMyAys^6N@MJrhbYXPiup8Aa);5$XyMVuc=fZiuT&!v*r4I{PHIA=;Q>Ovt50_|ja*wb(}zy6xfK_qg7 z8L_LBnt!+hb1f{W5&*;LI{V`jONjDybGLd1M$=^{J|r$d(t2#e%T%NiMCEyXyDTi% zJ;%270ej?Kby1!Ca|{y=r4o(Vqs0>o=;vbpb3zF4(lL8`1yY`Ng+lGJVlP@K1@An7 z4xOvMnRab`_-+S!pxi(!MV%jIqOI_5kVAWWD+UCR*U--&%8NR_{+9azV%Z1H5BHpC z`0&;X2jnpVcX922d5RQE)nObD`}``+uUnyaIX|^nxfnL@u>-hG7gweKpKY8sE|qi=pIF9A91$CZ2WtVZTEry&s)Zm zay>j8glMx)KuoQwgRQK$gK;18t}!0jxR$S;5#TpC3^ z-vkqF>)+-Ay5_@qtAQABi|@>=1}v9UD)?}0(`%-=G%&v2&!r(gepUZfV?(=n2Uuf^ zDaav~*WQ4zf05?Hi1(cP8F=PCwzXxT?d);?u=JEr(b2gRcJU?@lhI|@Jf)wn@$!Pe z-HDlK=i|8YIUN$gbqP4#2-R}-rTnlNCwK{9XQbO1KaG4Tpeype_c*^^W$>ua={yIT zd%9^-4Z`-vT=+GyneE`?BnB&tH3c&NsO)V0cq-Qrv=4qwX4b%}vvZ|o^t@hG2v9Rw zYxQGUL?KhOL12`M9WH6E2$Wl-zuPG%;+<#C;gNMPhY>^B4 zhlh~KcQk+neXxu8290`ufPL$3+je7F zM6PwaPi1Dnj77AL3Pe@j#$g6Wc*l42o68Xy`Ct3Z7yFIvY>)`{e+r-_PN9XmdH=GH zkq_A}(G9cNt{{()UW6Yfe?h=wUyK7mHNg*bPkS8j6F-CpdvTw2CtIZ85ytKz##H#D z@SL`)@!_`9Fgn74c5S}@KG#y?Jn4ng4)U^OVbvQcS*P+?l46I^|YrdH{Co7}p~=d#iu*gc%qB;?ZdVuoy2HzR=HR4EJ(;YsN*INeTB^cIoy`5A zw|T55oIiIFM`ix@y-9sY+9_A{sVar2&f9Zw&gVR%-YIN)Z66oGmFsJ-vhjDv`|dF(Ud(%y|vQOYFrcLXqB(%5XO z>a=?YIFq77efA}kKDD`*Uyy$?vL~2Fu5Y`>GP$mu70ebzI?FXj4%4dOSJKH_5k9d| z(ynK^33qxSPBz6L4mM_UbWCdv`F*eDy%7J~;Wr>^m0$8x0i&bAYvKxVy8bV_9wyZr z;NKM<-xCgkoHqGgtr&m{om)FR(Nkw92qcqHpuAz6WIcd-*}2efB#CJ>pKN5@@SAfIk8W%NvB6fV#C_D#fMYJ$m$F9uFejCHY_TBHTXq4eRsb0-k z&Zhwsm1sX=7n2ZmhkmRNtEfdXjWo|>3i0@3$R+;H!B0256MY z{*~q{wAiN_Q742^7UOBQVkT*ttFPJT0)}?Nqb&G2ga5o+-Jg#4ZP7(ks>>rBy&FZ;Qug_3ku%Y%I+FWwQ%^ zx$digH$v%+{WVz1_Xo~o_`|l$er08%NL*x((9YM4HV4jW1-sIj1hM)%ULoLsfTc7A z`dMv_>&)m!)m4|?6Hz$OmO`|NDB`E7c+uF>?S3Zw$e09L>a2Qm8oy#Y1aRq7r~E0D zVB`78T5BAzF}HK5eRsC*`8D6lqXyyu)w}T&oVo!hm%V^yFblwP_^9}phJ$rvM#n>%G7!gcL zNyurdds0X1klKv@{s+fV0<5sQJ7|GPkwK1Su+x*X6=wRJH~3#V*^|`+*z7&r zX18QvlTu89>+oJ|HXQeQE+E<{DqJK*2s@)lP#ud)-4ayV=Ka(2rA-O~Pk{r`Y1ZMa~e{@Tf+fWh9p2CaFVeq*#GI%03rPCme}91&&2% z%CFH2@sypf)p}OrM<3F}?|3Gm!-yd42a0h*zCGf#!YvD)?e&MmrbhKgjfFXKN_Y#Nk$>68_-bAYhiW^d3w(v-kJv07n%U|#PQ+2 z4>q|2AQGkQ+K}xeKbxnDD#tK*{$Uh(wd6^A&DggZHr3X8`Ae!{7pBrg!i}+!mCRSb zE3NeO8`Lf3Rok6mW+PKa>t1{Cw_9B&^1(Ct&88T<;J_`v zC)qm)rFmaRB)sO3wZj3|q#CFF>lk+2y@cCr1L~&1Ogq6~yL=h*-^{WwUwv)ED^V4C zhgr6}bP6jj6&ZdH)%Wy_dPgBiXXs8yS!x&=J?X^M|Fq<<7bBh)^o zQl^?=8z9g23)-y3m&By2Aye<_!7cxmUgjB{0p7fV)1YFf2V~0UT`=d{YulM%uR@Z_ zdAfS(fl|}nRUi+F(9WHY7trWmyj^*45WkUZv!{F~K9<79lRyMxSh*5*_CYVC;q*7e zY;`{-NTdMbI-@{>X>5|^RI`VRaw1L4^)`Gqxcrt)_xmkwZ7OJz5u~FC6q~^q!?V)z zS4NJ^5xl)OY+3~r?WZ?}OvO`?X|gpjv==-z`WtU_q^t)HAVb4STB7lgejoMlt>!-~ z9)(f$knfNYPqoy1Ck}I@FPSdpbl{{AM6C08AGe|krN;y!?vy?klCN7dWdoAcN(wNk z8Lzs8+L6}$5vGKiNoXmMjaSD1CbDbaCNyTSU)->LFi?+$I z&H9%o!olyl?%e_WNx2!H6X$d=|1PDQgq2?`ieW5=~8%m@SF1t#0*Yd=dP3Z9-F zsh-pjxbONBl5sTx2C!jOf|ef#^XsM?#p$xOI|f^tVv8u-#Ty}bGeo|T%dj9he2U>F zVg<)BP=*L589O}Mu-!W{aOZ}phQi7x#8@mkSXI1k2i7{#I=VFTC+90BT1F)YQbZNM zPTCM(&pc)Y;+=LSVT6TC>D-NnM?H0cMTn&Ndughb;3v(qGLG|8g9j@i+hgS$`0dyd zeInA}<1A10iTM5%80)<}Z+k_6m=hSYWF1Mw6R&J3E%rWzuw6^JRE*7jbh=D1T1${* z$Wi;LfQqY<4r#WGo-UJ+zl%19k29-*j(74nj%?_7Au>Vx@uTWgSsl3(vwd zm%#nrRogA}cM`yN^kh_VpE5t;5nc5yqsXnzDHqnH);~MNZTI5?kA%TSe-NSNz~7W0 zQrW-M@AOqO62O)|Sxc;+B)ifta7J_uq*w5n`^2_Fj^=5xFR}AA%r`bBYcl5iz;gXo zM>E;`xm{-dhG3=J*OMK}lzSZOIEZj+GTCde%xphh6iaf}CLC+UgEN%RvVvNMOC%f` z{8Tvl6S}v1J*3hJ)THh(?HweZm}+a&EpYYxnHIkL%kGnhtE8%1DhY3JmV*D-z3N2T zgDyGyhZljewjBJ$A^r4+*`g!O{8yGxH)ug=V0ZgkcXPtQH)O1rAN!vHr9(eRT4!hf zIRDKq1XlwX!pQEoh4=DRT!vDXbKjLT(Z%?Jaz`X{_=Ix~Y2Af;{&xQO0_Kyl^q8;r z%#IONMlFsOg^^C_saysbbu?UK>omAdH}ktjBJzfP0J8AvAh$QjTfGhYxmNl|7?fRQ zPY7*2w3ko=W2VjnY3ibpj$wTT@Iz!=n0lJjbadt<#W^%TK*z$cU<+IBG)+XefLRFc zNHbFmIBoK9T_lhyn{jC{R~zli8}uE3naakWVDws?-zu&_Xo>q(k>47$sm2WR3~=!ru%bxW)ZtTBz*@uF25E>4dw+cXlo6ljWYIeQEP9{g`+TsU9s%N=k&=^mo+5c0UO##{fRAO9z!8{%sO zcJLw58II2OptoCG4s-zjt?Q2f*h-Hke~g=YLD~Xg-b5Ek%P!)Dl@Eniilv7U52Cq8 zl~&BQ~J0v-mo%~n1tyCd5a< zmhS2S4^*sFu;t&u3x~uwN?S}FT^sbWSH$PCZvk{h;7O2(nE}a zMenUf+FUNc&Mn+{7c_qHc{{%XfMQK2s7VYEVd-jFDB96GOx;f2XW-;t(!vhgWmugv zGwc7#m-DRNSP0VB)X5NHYUU{>z{4qizJ|y%A_KErSA7i;;A+%Hjh{IcYCTnD=fZI* z3&zr9T0ee6`Y{Z>34$j5+S$c06us=4AL)<}W|J<0=Z0{W+Fo7kE5P!YzU!FaV zfzxJ2G8ldrdXd4k1ph>@(3R>%Vb=c-ihco6Z*0TY%>Ab4Iztq&z@d`@*`JHPnJW)r z-1}aoSqvVyFu?8*Tzhw>{LET}JD;xIj+7sSKK#0fq9l^8Ev`D$0^j_KfCXU8~T&@l#Yn z=OXj$Y6G2Fz6FE~SodFR6ygfy$EE^D^_pg(#lE-GDx~MKxfB>UfEGZU298fv#{i zJ)Bnbi(mI)hI@x6Il$wR-UFzYvtOA&yeyY}kjE5o?DT1rc~Phh#hVJCTrWW~3qJLG ztBrqf7_Xo1;zlW=3#W3;y-?=}5KD-^}Ur`%{E&o>P$fJKH7$6{;NR<>bjEYt{*{t~Ad;b@LtdMm>@{%g^X}v3DMo?FIplb|+Cdf!Udk;cn zhZbvV?ICuz(x-l_)&0{&U|kcgp5(70?N}k#Rrx9Ft_WM*L0lQ~l}~!5DcmKl3hN;2 zR}PnDgNuL8-Ryvyo9IDu{nj6^f-N38tGrj5zkM;NtHiW78C&>R$l=Ea08VTN&jHm)teFI#`mWFdQ9YpVs6D$RvhFB&&h`NXyf!BCG<1c31J!h1|_^6nT8aaHU)zI)am zZ>3b9hxYRr__a_z!9al}<^pkka$hX!&H@0`W%N8YwF0<_4B*CBW91-U0YfKL>(U-6(c zB)xyo5FmtIqdT~AnohBggd!fuO>HW2z&0PC&Y0r{BpgsPQPMRPU$V61mL#4x;Jf>P ze{~_gBaD^5Nz4DtMTs8izC-^37Dao<{TamnFZ!m0YSeR$GZp3UrY2%9wYCj&PO_e$iO$u8r}oLnQ%>MVB?9NPzVY~ z3Gb~-%XcpLrd(?xERdjC>(@<(Z%FaXrT*3PDZNHmZhB?y zkT9kqWv^4m2GX?2evHn00eckNDCh5$E>ytppx(!vIBa|kETa$puTHvY_;2kf^T74@ zyt!lN!3!#EXOR)EU7N1!{;{9}O^GFB)o)`d9V|u^rqUEi45FjY@TXEi2{trw5H<72 z;IYybsCu2OZMlpJ+RSV=m5p`UeVju{&S!cw-CJ@D&d6x|OP$#7j!`;iu=?!Af zq1MiqU|qNyT2+cmcFF^Z5qy~Ujv%bJmu_4^+J!7oFmREw1K9RdCMMc%*DSPNH1U!a zaXg#tw%1!pyod5Zg}X30PdUD)(pShMKr4VpU*)l60_M%XB(f-k_%cA~ zv##WL#VPZ4Ecz!MdwpeeAjdvEBcYKBX#w^h!XupV$UQoan@=MDHV>j^lkI7Q_KF@H zCuMM9Gaj@=3dRXp4+i~~k92Y@sWr^UIpSt=tvg47%dQ^N`Ld{?LyLg5uM4w353a0{ zRZN>hM~8hWkVmPX&3&m=z6-$VU{qS<9QciFz~$QqGEk78sS~FNRN34tK3!T}T+w&o z`#c{X<9<7)OVlpF_{u^+o`k`C%g?B^{y}}+#b@!O0EX7nowPBod4iMlFiZYxb%Ob_ zTj)L=(<@aRj7lZJUr$m@?t||zLw4&&y3L3)4jd^lA?dhS3om{^Dkig* zvo=*lgKQa2UWVHAY~8*=zvXYVBPbMsm3iVuAAx)2CrHopfY2BetWRA|onEBB`|s4N z0lwD2&+*FpI8ZpIGfWaW4aQ~MMgw}i%g%3JBLl-HZGV71Q}G0q${^577t6r_Yq@Wi z#oo51D>2R1IK)}nn5;83H$5oLYSe`67k~2%=l;v%eD$KS59fpGvh5vK8R#jGH$9YK zjG#tn1oOlW;9xvH`LQgp<<{U7s*RhQ+Bt@E9NN{aC%Z$Qwkg@pmF^`aLL5EYyPZlff2br;L~-?Ju-GfF$j!h4(n|yD>=R-6gLI4 z?Iwxd$s`*dwN?2rOOGCCxg=aWRiNP7w;?Bw)eYN49BWbIVyvEF$X3;FBp+1FU!bE6 z)nEc+)5wQu*YZ0=@==YAzwl%XVp0`7_|xJ)7j6{e1XJx-@#t!r^r$ZC4;Q zik?ar$j~wk+T6 z06|kfQ5073{mn=i_jO|UHW2Y=VCW=R`G*w|h&Yrm#vv3l!0+x+gmK;o_tFh@EM6=7 zvN5!*5yWF=>X-H9NsZn`(}I4=*O@_DP&BhCj>yuv17nE&eLqAD85~^7rllsgGBx<1~3Jl5?aiU~}vd_U%HKk;^bN6WAM{Q@maza9VTM-;9A_(Y7y zNu<5)7MA#}^8#*V>g$U4o>ZwtDs+Te5QS7T^^GQdI^fiAB543=Y9p#~+${gC{l~#c zu6>4!*gvCnxq#2vCZosj_}d!9ix{DZlwou%a&}$N3onjF zZg@J%v|36z=ptNis>Ey+me@RoKGM6d)6Gk%EG;RmFY?j#{EV!TcZ@8TD;^#X^1p=~>?hxrVtV4Fr{bH; z?did?J->)vXg~l$QiSnKgsgt|A;E|Lt+evxo|mQ` zToq2$QFM|r|Fz`Drn4{~WS~D#l<4g`u2ENPV$jFu^rC^!rnYLiRXMemoE&C4w$NCv z&V#l<7BVkzBge(uZ$uvwm{_6;C(EKw_|L89(dbX@pPN61@iEim*~1{BDgDm(b}4Yn zxb?lffN7$5MZg8kr9bJwZSoAbvvUtxG~VEZ@VwMs8x;6ad`AQ2349FII{E%{qW>J_l~3^N`~+}l7zWnwwE3fvV*i5N zi`PfJ5D6stY$dM&(bWh1pX~+PO9~KuzKWEN5_z6M-2z;UKH}RK>6J}eN1a_vH#J!n z6i*&-je5MT%;u{-CWN2?k!?aDjE1H-<8OU=8eA>gDTq9NUh`>=bFqMyEg7}(3vZA6 zwP(HE%E9y9j{=rU6yy9N{Sw-mxt?pHQp%nSBrU?X=WSueW+Sc-_ggXm0ymh10j4Q> zxUWEuXJGsRPyuaoM0S!ordnL(*^@9GdZbrqJ99~9-3y2YF4;pOsh*YB+$bW*ukMVtU)TKf}tn}LxJ%|!DNMK_{@N!-~H|}XR7hyb^ z{ItqM(~3r+4PRlutP}al+qJj&^E-rnZ)+86`*R)@%I`B zj>rNobX=yC4mA{Heo@hUi3SDVC68d;hdlvl#xdeaDal|u20WQ@LjmrUhFS+Vc2;_&;1I;W?blM{&!EDfb+9DguY*~7PLgMEx5v@? zbJE$%M?bg3!my8)u2`;`KpYO@&;Lbsnt%0`Hf0MijSPGF`GZXqg$oqxM+@`m6SYm0 z4sm$*sln)qJ{{k#7W;(njoiR+@5|R zjG0siYM_`@ZTv^{ezRv=zA98SCrJeQe{R{xcbabNFy5hLb3hRvG!DNi1c zEgZ>M?%BuOP1i3zx6pj&yBXJdN7XXgpw!GL2x7CjqR|kY()L+-7|G!?H)HYmx-4C>5A?Y04Z8=Aj1SzbXvC$rg6L*7&ZtsiW8q z-ZE=San1uJrcNCP|RkXAmi?V~`_`v>a8+rDZ z-f+mzpvqKow$zhbv^==*$^MA%1-ci*3I`Fhn9^&B8f(d;QDTk&WGi>&H(W@RwMor`8e(g(2AhK?Kt|Fb9F@{)c@Aw>En1NwUoUL$7`g1UnsX z53JvkfVqNy=JuiZQ2$HMH&-4?0lxE`R!MIIZ0ZkD_voE3CP^1u8NtJQ+ zt6{1UNc1X`CIFCp%8`(5>9gdHQH_OQn^Z4ZcB=O~GmKEZCIcnI(~>^=!F_#qboc`P zNiw}Td!uHw*!Ktm6W*Z5e3#MkwG0wr`V?h%z8*@zDL< z{q!fc*J%J!p-?N|RC{yOw)Ib)>b|7qtAJ&}>uScI*MC?c%?cXoFd7ux(dpW$&C^ZJ z!x2L-0n!^uCxIocILcerUVr`lO>+c#0&4N&<%X7&E#*@jqtUhXf*Vh4@U2aJdZueg4QOZ6-ALo^->6m%S!>>ed$2@?&XZl^Ia`EN)6iV{I1+LyEs!jAU-Rt{NRz#c z3xBHoGBM_#H3;7_VUJFg&f3>XKkYeIzrJYJgF-nt`UB_QAXaPi+TYXY4#e$>Al`aG zeJ~gPj(m4S=>GvWy~hph0JVDbEz^y*xXfelc_-9*@E=5@7;<8lOyVa+G3MG7IA8yE zhBIFB_-r>=Z;de2##IHI(d3g^1@Cy}lW4bx+rP$Z1PTL>FCdu(YGj)6BW6(gU_YD# z_w>bjs;d4K4R$U(x?&L59|r+96_f;hQ8d?)j{{=DIJ)`GJhx;RO7^HZrr(0^%Jh;I4@Z^4IT3R>a9G7_U zyjR=+RxapM=+M&)qPhpA+vUcxhgtZC2D%iuOxyl7F_#9snr>7FDtWe7*oq^O)XI*l zQe9^{S{hyw$`U9{{0=jg!cXRKcOD|Lm>=)lg;2Q7%#Nko2b)35r9v#m(sZxUPenlI zv-_SLiaA)Qb(D2i))fVv8^lG*NAbK^Lnip^qTv(=7J#5lCvHz&S3HM2x{S&2a&bEx zP$SwBsobl8?Hq3kGVX8fVh^D%SNWQa{Q;CDI>g8Vffx&hIGWrl6fjFrT`Z{#{d(hz zf2dvt4;yy|Hy=$qHIpuW*k8u{PjsQt=3M#@%I5b{W}ad}-|%`I#KSv(sI^ z_@`z(-YmndAJ5}LziL7~;{!9|Q&bxXbfzIq5pAN(yP8agaAV-pQ|XpPM!gDL<+0R} zDxR1NLR}$p3{AG~wDk(0e%OHBL5@^~WNn|R=yDHQoluJA6H;vRzR-3{Hl zm3%{8|0rGS+8gC{z|MX+Dh+P9xmPZ=C0St;wgkhHAGy{L9))(#ioMTGQjQA|TSc*D z-acMEN~#T?6)hzcNSqBYTqNfIlma>U@mhSa6Tm3U0Z6%hK zGc6$D&wCRSHlxJ*=4T&b#6KxOD@*941o?Lz@}MKbOaQ{TrFw)p=C%Rn^0Fyc&( za_%N4c*HI>$7-{DVc&LeP3POEMx+N=kymL+;Y3~#;bSfZf%ae6XV(4s%{8MV6B?w< zFeFZs920haqCH?Aw)1N}|Mq$Wyz#41(F{c?GOmiGqA|Ze^2x~Uv-cIcu=~4Sd}LKc ziRf0OX>rtkaMik1|7-<4HV9J{7$cS-MPA|sg_5>Cux5e#?4l&1g7kGT06Ycj0nS=f_d|x=$uyZ|`r7mUaQxgS@MYCr=*VrNHe`RIkgc<|?We zmVG^5-x?zcb;5r9;ir>lxPc3n#zvu5Sl;FKW%<4C+_C-K3?-k|1O&H4(JQ28UViks(d*aJAn+h)#TDP?triF4?INCI{E&8B_-DZjH zf2$=OyWz-~hep;$$LSJqnqx?c7D$1mm@x6Eye%ap4IdjjwsP5{&pbD?5t@AfdLNWX z2#iP*v?AfhZ&@{N*83k6#ux<9Jwbd|v~uFDr-S}JRm%2J)>u#R8rW+;4te?LZ?RZ_ zk&-5pw8Uy0L&CD*K~M@$VGXR$8y|nxPl|lY#7QEKtDGw0Y?!`CTPsQgR15n%W5uzy z|BYaTo_3bI1Hvs``=-U>pG*X*vnej zBLk8a-&kmweZX+ac!HpDM%4(C7N7q0Z~MLD8ro_`xp*nBQbx4cy)HJWS?!U(|Ii{L z_YqtsD#d6VD@z(hXfAh7zGwcSA(isa)hk>pYg6Op1L|YPCyu!@4{L{>3L`fQYL44~ z(a%EHY*ilrRhL1SvU!`eW*Lv7qVxE--B7acL6{GPj!iCTwKT%szHU*QuVxh*mxg=) z%OMHM<@OEDcKe2?THWzSvUj%IY1Tn!S9>cYY6l~h~yB(iK06YZp*E?Rd1!V;Y;1cbX)D6L(}L@X@PZA-()V- zXlTGM6{*v5v_g@LLescsOnvw?T7 z#a{XIKYQl}*}K8i29)x2ZK@`EMg1SJg$NXYkbED+93R*DaG(ylT=&5Eg&x$E zS{xkxuRadupU}$(GdZSND9`NHN$j_D34&K2!$ldPwA%B~*n@~P*F&VV9>~K2TMlOs3uuOyAJ+tMv3$1YLWj%>yj+*rPxAo(iV@^eAT!uM6fSo!3D+%yF$j{PM=@#mNgU`3M zgggiNp1OiJP>x=aVZ1kIrH0}?{2uroln2@gf0wx9sspw!Z|b_94;pCK7w)lQzH7WX z+2>+OP3Cb%PzZ`yS>3ZbM8myCXbNDK{=z<_feC@Ft6pW+?eDaX&;o+uf_Du4gIcfI z?)-}qg9)O?*Y!vK#oc{(t|#WD0Z+fT zLp9u9N`$)IQZ~>%LEoVT7dK)VuS|Vrj)0cU;w(;5G)n~3S1C5^n(mXggK4WY6kc_~ z==29?_Pal#{u?1vtfFwT%xMBF*=vkM*=`tJN$!#LZ6rl|R%1m~(r`h=8CcQ&Nl$OX zG`yysm?tmy{+7ux7#518#F3oLDYDF?3=7lB2w~FV{6DRf^`wK(7~ z2MGSbw?{A-3{AWG=h65GBhmBFta6m8TbDiRD(7JrC zqh*Zoi3GzD=tG$N1LJa}g6LC&b#P)(V(WH%7f370d|Ymbbsk|z zwiwTEya3kElTr3JfUm#B8HS)*IUV;S2vxPK4Q=*N1K zg4?$!vt-|0dznqwc9e1X4Lcd<709f2#Ej5|adUzZxM>;pv$W^`W}S~aQzy0*hG-UE zBcf;n&qC}=w_YLoBI%`^AJn*CvU4vrw&%SQd>(g<@x7g?vEkM35_$qv>PA_AdcT(< zF8Y9+BwpxD8$X|yS~~g*#Xm)R9u45}eK^&4f12JmG#~3RbW*h%ejo2VMw`#l&Nm8X z>I$hJ13I`?V%H05{9$-cPbI{@3(v%L!7z8ZcWZ~xOvc`j^> zai5GPPtUIt+?htGp&j}#LGqSq)=ML=aU$*meKC%2S+D2R1mpRD?8yJ0`o;M9xKh&1 z&%F{_!0Wx@E3mBOs+TKJ27Eu!BgJ^$0W^X7-@0+x?1vNe0&2yG|31XLe0-S&{~Hkd zuMkD<_E4|HA{vahAdh-(!j%D!R**<)Cf=FzW8#SkCYWG?2__^Ky2a>_6PCB!SnRI5 zQKS#`m)==$Y|vMCZ)llZ__#mTr2VXaYgdctG+V?aiQy?(W>gV&j1tYwnbk4?`}OpM z-=_Bh&WnmUcPO&U5fnutSVH1>xiBu1OSyMJ>y7D+eyEUE!AG{7lW*SuVx-&-L2Ri$gdP)qf>Wbi1@JGkGsJ8thV(Fvluox3YE zMUjE1G|}W@QKxUh>Kxee#NQi%4cLuV16(61LZn5FBs5h(#aj_=p{d1UoDVqZEsjyJ z;M59r@jUcDd=n1`&dZ2`f$&9rGy|Dv7#eTB$YIGaENRo+rSn=CgkLK%1muZ}PFn^P z1ndC&i}_ieJU?tM)esSWZ5a0T(Hi%6cLSN0LDbDc<2g~%a7M!w2`8vG@AiKBz=7MX zC>d-{jMA{JQLuGja(v}QD+dOYP0=u{!JdKd|Ko@l_fDl4o)kz~;3*mv_ih<$9Hzx) z8IJX}H>avCi0r46)JR2R36fDbo_XlSr%tXITnXS`gHkSWlm*~$Y|oPSswL+E12trL zDS>kh5dH26>QEmy$eSmtJ|7%nYPEitt%eS@Qz?-@aXvTU%7)_WuJ~Cp0-GQ&{cgk7TH%|HNAbEy zRtN+GRlRP}7i5vvW&9 ztB3_NBtvn6MoThIgjw+-4TNvSa<8w}^xN4Hi>7%_!#Pz}SS75@HY7bGVxDE)+gy8V z7EOWTw1DFz&fz4_(+o_3R?!)bq=u-u%*NCX zxBO^*9B?KJ(Kg2#FERovX#v-kyY{`Cwcy{?j&@N<7fYP~#|oFqU9jyEZRzp019jA9 zV|7ozvg(h%;E)?+NCeBm2$I0uzdy5bz_$aqrqsiETE5WLJbr*`UJ#YOcVk(V zS3bYy0BA$LVH-pa7e$HSXqqFO)20miaczx4R?VxY0J~J^WE)k&ldh^fCI_&f{QaEhwk;ol|}kGcAK zo%s4^vv{#Dk5$WG&>K{~&=#?B5|>q3Pz6z8sb}~U?aRBiCl5?83a?L4xPolce)6gU zfYe@WQ@6XTbmk)Z;h+RXWHpVJ6(07(F&mM>^(0w**w_2FY4@X-HGhr4g|wj35=RjXjuX=Bb-GVIN3~0aEm4KKi5==_<;7cHPitrz zFZ7Jjg|rX*sX=o4stqCrwH8E?=S7mm6`F>FTGxjpH%^2kr)YOCzDfL81kPp*cd9X+nYr=@GoX zVH&<6%)%Nxb#B4>&p;RQD;snHR|J*Q6owN-=GfZg7lDCkf^AP(cH#nd4WU;Bw7dSwpR>tlmonN35lL@A>M%wC}9g-b0ORX~(&S zEwS$<+H$B{8O>isX{QMlLn30e+>71Y_22i_?gjqp4eosP$RoUKsE^B1eLi+8vK>jGJX&pt zuYwuz(&ilr&SO`2-W>nSlYa<%yo*x3#^$=={ABUi^(0GC62;>xLBj#KQ)Aw)9>vD} z(0=7VZJICM#d8Wl!2;>MF_QX4RX&Mj zdnK)U6Ci1vksLOb#c%v1oWliz5><^*p6$N=*_I0jJMY&&^-sUD=%pX^v!SQ1s0s8r ze@0l)pGB<3xotz2%;P$~uF>Z6-=%dj&SSwr}(G zR#5hbh8oGdC{ctWYXqSZH}NNLTQG#Ld{ctPp-PPJeH~-u@p|yM+R6sc`XEk@v2oT1 zOEMFs^VCI8f7i#2(%ZF8-%HdO%XvM?azz1{#}(MRm#+P7z_*RjOlM$g^Qo%hQaD0V z0y;gUrXGCxxpjenjbK<{Ylst7Q5)(??9I3C?!P&sF+_A38K!6qLvb|COR}oHJ#c^X zMY}hrp)_9>>2?QHO633J1=M$sBcXcQM{(jc=P# z505;b1PIaT)k0GkP|u6d=|ybz`DM4(xGS;(fvO2C!-}*(F(ORC^oq)NzkxMxv3d2P zreNR=RE%;6QgC_YUaBWw^#{bf;k!2cGwyU` z4S#_nRZ?UrK?^&mf9=!;QS@8b7e@wOv*0k0TWz!&%BTr}a1C>N{RN_~=H(lky{Q{T&%#1e01F`tMOf#jVJY+V6P&MG%6#n#lDAscVCq-j{8{;y%Hg}8BD(~Z{Ad*R z%f@xH9Vj>cm9dgCMQ>yI$~O-zoYydt5J@3uT2@G26xCpC;S;yqdnj}D6B&TSrLB?E z@Osx{|Jkx6fA%{Og;$I~GlZhik|;=}7hY||UU+fw!qiC-*DlN9B*VxA$FnTFcKPt5 zFUulIa}uR1?~L)iL_@VQDhDmt-ikG8y#9v4??z#~NQEURoELbFhH)Z04Rx}9h@F1X zaq6X8+oMnK@c4dmp2wrg{)?vfS=nN~3ZLlrq(?^c53z%P-m-tyCk>2*99|beF~!aC zTykDcj@u8razJsyMcB9<)B4z6{>v6wDuGkHrfG^KX<9&wem` z($wQ?EvO^sV~F2v5#y?TKgNyRX4!|0c){K2mhV8xRl>Kz92)0bKGok@QHH3#0*}9& z+b4@&MOEJVa>T64>LYfTddabdrm;d!1vQ8U!?_Q;_szHF^!w33HKK4ZDV%mm1#XWL z0x)QG%V+w{p1Nz<>~zQ7iPupuqv{r%W8=QcmGjEcctOOpti=R{JIaRp_sH8H^*npn#JVVD4= zmJ)s+O^UN0TVB1&oRR-TyonoXjX3#sTcM`rg0x&Ff_$7s)TaD^5ilrqKd=V!t3wpx}rH+6@$QemgEG2B}km0X_!3P-8A&W@G8E- zu6?BI?K$~X!v{`BM|ZBy?M_{@Oz2cgKd_R*vosCIKKO?4z$aM$VqsKk{MMNc!A))XXo4;@RS1B zi5v7ZGcCTVPhvF(?^v+z)jHuPt4}9I+86K&$E&QM$t1_#JtTEy@jH>nVm@bn!;-OH zFD~MdYLB8y(i%aDvP@|$cMY5V`|6s7YLDN4mL4L`d`7qHOhQ)oC$@tgb*}9%$fRTB&(#^2davG~IKKWJ4V?Y}Q zHxfp0Y=DFpClAW=x&7|E+-|BS7I^$GwdlU){@H(FP0PuC6DzNIsd><%_4E(6u;Isf zGdi>=CQ-8(U6N6*f%$=v7CoH<13yF+l`w0Lc4@{bfZ>ohzy|f(9_2Vi{r?X(dDmmp zUzrUEvz1mO!b~C=o={1Vmq}dtY4$rC+kBSZLI2{TbHPt`9S)`o4h7SCosGB9yR^`z zgZDu>sPAByT{ZarAZO_N`w5F-9`(GULvfxnIb>m+!Cv|Gk8`_bfVmxRNOUVK!E&t1 zsT_fym|pAs7Sq~c&p~zE4{d>?^t8Gz>Dqp4FeO`tV%vFLv-hbB`pK~>*wO;MCFAtl z#hQ8t8r)zrT--|_=`y3sia}^kQrGM~IVYG7d?~o8N}Gdu5MteSh4<^7TA>0zr*0q6 zR6k>y=`ZHkL%&-L3m)}yuZM_dU~W(s5;Ot_!~p+t-NE#~dcF%nUQ*H83-79{^;_~C zI(~dNH`suOU(#hKx~pf9jl73fG0P_PA z3umwc$9Jw;;cOZ%j4LiymGg3C(eGk7R^T`mCs+}OrEz(76ghGp!{(fS@V?g7!liM= zMP)RD!&j`Ul8j|!pzQP5_969}zu5?=gp4UFdE7)7MUaQ(hHD&a7bSxa+F3(W6u|$t zL#k+49L?@L_Qaz7O(6EHIAzN+K|{Kslk?TC*=~>Gk|pZw)RpO3_ijv?0-caxM_3kx zot>?JP!0NiA=FeH(bc*MVk-dv6Zj!zBvx8#xwP|Trp3yKCp+xqM~5EA8iz|-ifen1S10>i z9EtM+M@uwEkSnWuR<9{0aOvd;O#uvnCONzXDUKJ~H#^$=j>sOXRfS|#S(a%f%u?q@ z8>;9^jxofd1C8&9Y(GsXDy4CPqS0*F6-l?ou?}Qq$7yT59rl4}T{eOtd4Urcj;AP2 z2)kkWNDoqe%XCx~>5kKFKAgM!3DBKa(hYAWIF6!tg6CC5eVu#$;TvxJ&OSgNs}8!j zC10P8YS#w;sHCsC|LLN>IZ1@7POsyPle)VKV3G4A&zt~ z9=1$lJOlmj(JZuH0DCHj)(h%;cwI0rb+?A}|4u7{w8*?Pll;+)-9NSRJkyI zz|cMli90q5zQzl0MbY^k7Ne-Sd6fUb{s#6jurGmqs9`Bdr0NLKFK9m4H^Dju>w2QT z0RKVcQSc0uUy%`d4uJ1RuMeg-Uu&F4wGRbANVff<%#iY){5q(DvDan|Nde5zf=B%M ze!&Xf&;|HOx(NYDH}?#t*8$;xz5ylu6#NcY``-hEAbLt9hvvcfEPPiN8tUbp)BVuy z)z7!{ZA0G!d0hrsST5)%n75vg6BjUV;Q2=u<8$~U#Jqv?FDo_le1HL*C97Ty;YCd=P+Y`QYz-`ro zwn(6|tw3g|3c@TEbBJ%}O&oW&37Rn~;>8FGmq=107@S~I_l$gF>)A{Ua7H6ad~4@) z^q=wi^z~0Rfn=nHE}0l!<~fSwC6XiVdE)E$9*H)puS5>5PGFW;G~PM zB&TEkert_dDu_{H5Z*(-@T6Rwef|M?iW+dZ=bA)`u8G-dZV%DpQ!AwnUs_yE?=ju5 z{jomQ7+Jz9jt$56w{0;zqAH~(Q?w{cl)&*MtV;RKvY?FX>j#5X?yUY)NItyEnvQ?5 zwG#*U!NHtu6u(g>1AenPNx{XSUE0QeU$y?J(X>K4xrds?mRc;v`Pz`lB&=unAhhQ0 zs~TAn36lx%E(a@@rz55Wg-6jORY{2LHr9O6Sk!Tx`jcB>zrQXdi-lNtl2-^prbSth z-@Y*7xpZo1A*odfAq~4!(VZ?AppFo@e^yHaN42FF-m9@7vUQrQ(Ht((lqe8kR#rq8 z)RJ!O7;?gX!$T{PR#qHC@i-|6I6*QviNiu3=YMoYAQiRgH*wrPX~5tA=A-3E6eI8y zMdCQlGK>)BH11_xF5VvD8>flm@y+M&{$OZip_s-B5<{?>#uMzmgV)t8E)?q!;|XT9 zG{F-xJHnaq{6P}FW&kbi0v=l@1q^3R!a*<_5W;oNlid`OS?Nqff(!`q6qouKD5W) zc*Y)38U;sDjxF>EhVzBAZG*_^rGlbCY3G^y>8s9RT;bB`7swT`FBvUJXL5tiYA}KjHW|IivYA)uY7S zBPcxJ42+aSEzAKh5}`XfZhVo?A3hD`e1TzOaK5lOIW!Hgrn6(qqc2zS9?A?CEqQ}@ z=M_nbQ)xxyDH(5h^v<=Xs`7;@yKSPRMh8$*2o=@E@#DbTu9>qrvSTWWku+6R7(y0l zxRcjL-5k0)sOxXs-m`H;CtSQD;RHpBBF^B3PPj%wDGaFpi`IB|N9}=IPu|}ch+tm1 z->9#Q#>%8dsERBJE;(D3$M5N~SI2o-(V?v713m|n%gOpQ!2}b`^BusuCcSQgdEQ(yNRDxwO*+v8 z6QTore%Z`@%;e+B@Z7sxdV#5N;(JBqn=AS`UeW0+YXxoh)rvQ_WR&e|>!G!VvV1G05xn%MI6XL_O877^1Rf8Fy!5B>YXA`a@ zFzJc18Bf%>#(J)rbc+e)8Na8Q=e!B#e8&tGb-h^Q+!taU=R}W3l8M6Q5{8;|=4AyZ z;`#V;zOHJ;*-jIJkaCsLOD3HbgqzJFxFpcBl;3AvA>)u`qJkmRD<|U$&iw)9bes|; z-|AaV`qMo@=T)~D&v!UYhSHQM-*-t6{g4vp_a&uIh|5ebn{a8@wFxGe5Ph9Rvzv@p z?ow8A8n~Uqi^&$dCh{D1+@}rd#0~`VgVuWLlU*Lg>mqQ*l_UC9uUquEr>GY$TsZk@ zdjE9LlD3Y}(ty`1tEGqI`Hqff?wZg{f3mx%TuF1eCXtLw^m<)dp0~RwXS--zQY2B* zBw6L#_f>zJanS0hfoQTl%5!@OhoVv`->+S4ii(SYt(KmSlbzS4eY_qF?u|)dgW=Bg z=LLV|P&DoGe;`Tow{vEMwF`N51qEo_Rpj<0Aig}#Y}qV1@cW86nCrfptT zIeeQ_WEaVD@XodtxwG|ltf_l`*K;2<)}I_O-r0P4IjW1M7*)k3is5-}`nZm>n1jR9 zYeJ1|0;Lv2zO+!Il<%Xrw=BoAYk$vjo~)}s$qye9E!V~HqDbQb5Q(N=kJvT8*SSjR z`kPCzQ0}`W#ErKuB?8ziH#y#0aofvT8(Zm5#)P*qhu|rf=FU}ysG>5UAV*TY{l)y7 zy>7qi+x5_$zpWa*Goz4QoEuvMT0?^de)rwlWbui4^Yc6E`I{VrS5C}$_k9XIguym4 zIOiH5dcAoQ-MM44{G#Ocxc!q|Zr>oUJIC#JPf&daraX7%`03PiM3Zt8zPN@vJ}$Vk z?e8~%vwo1l*oyfsHP`QTt3DTn6Dld=oFsDe{2BeL-qQPs6_95$8iuAY)YMPTy&1-h zNwSP^+_hxd((d)@=uhyX#`yeR^)?qxk(@viG|v*8K+vQu4LZj7UZS8%IpdW8x8J{nf|bk7dx7>dF+RWC(6NNyB_|l~ zVPF!3|K)`TZ+@BTZFQOFx4hPuXsBOK`dv{S^(2+kc9r%Vj`h82m-yT_!Gwymj$&OW z)yk-yiQZQ$>OO5x&^(!NbwKq5zn3UJv%HQ|RTE{(HDFixI<0<{&F3u$eymXm_m%2V z#emRw^Hk^@k5{|qMkqz~D>(|C2g`S&Ddr}}$S>EAlfO=i@qg60QBrwcQiAxz zlJbT2DE(o|xF6B_7b`!U6s3PA9cqFJiR0@`xU%_>tF3?K9q%!7shD7bxv!OTFz=_z z7Al!TV8T_*j})nEf3*|;re7W~PB2hT*K%DdsYx11XgDXUooc>*;G;VItSHmmttp{t zv=wNzjB>2HdF1V%e4VL3nQJX>^p2pm0)PIE`BG z?=$c3YqmLnL_4E|J;^BL_pz2=*5wvA6e~UpR*T1x%Juta+Y~Uu2&3SOBdk%hqA8-l zk_`8UXWY&a+r}iJOxV`cjIE__Am01T8eci6?=2BVBGhEg>v(AV#@*{b0#-^l7LA10 zt9n$?r@FivAt@>=38JiVyXQY8j2r1o1J@HZpwxoM7ooS$@lxw1$E+U#Te=zHgRgHV zH0|maFkVudkEAXlV#2odzA3t4Q%`?;rcC?=QP1O{AjwhsqJ_j(Nlm<^lJt%Or zeg4DVqn>X8ZDV0QAUW4iA2-yUFu?~igJ@3%k8Z$d{_(MKry@FqWK{; zR?|d{6F44+?TGK%kc=pLilg%DIrG2Du8l%3lEx{57buDoD1j1S?3$pHhs%+TpX%ta z>&O1zKZHhLmSlOBV+ocPNP!PCh5YRGU^nKap%8eQqvxStR$jxm4WEwCB}q`O&OZNu zJVkYlRsF6>l<1n6t>zB(7O0idhA(v&+uDB4w}zzAW@(yZ-?TsTm6yQz+t~Qr4w#@a zgd!7+pb{!hyk4jK)N@q3WZ2R)J;BFgdMW>hA=ZoSXx~Raq~Y29$bskl!NQNksj5(PmZV9M#yBotlqkYme_pPs%R2Sf*tBsxge)jQWuky)NR zzt81WwE~|y$eo+3Dk;D2_#!}bgsCIdjEtE!%VUoF?|Zx&uSFJd(3;AsvcxDPEteM& z$77E19e&I>akvSZfAXrbYoc56XS*1J(w=(_+BO zkFSd0g@X_nf@5$TXGvV(VbZe&v_rvFJnrcC(v19P$Fpes${{J-rKp-aSMBGPdgNxg z$L5Ou0I(5&; z<^$}r3+b+Qm5m1veqL1PQ;r`-9sKj~3?Me?6+tk?laxk@5+%wqH>LioHNI#)+yeZv zl+;(JvxMI#$~S0P`51M^EVx?c7;@W^hSoK$(1NQRj&rFKL{EX}SBDhj`rSF|Ag`*p zWznxrKeBB1+z!rk;AC%v?!k}Lm5EQ2`T}hl`W&Pa^j1k#A`5#;3!r>Z?gT4peLv&a zeb;^dCl({uH%U|6$Bf2zy1a*)pvSl9EWjCBP-Io2 z7)pezupz5>+41#D_wU#`9#nC}SlX*jP`#5~qQKH3qbf8ZN%mQv=hdIP#~LlB<`jEu z&!^Z+R!*z{zK6>}Q%A2j>Ni>G)cBi?w9%$< zw!CR6zbonc=#hENvCCKO(C)&s&d8S-jSH>qkN3uCgIlx({?E~K^YCs<#y5;~&BKcvF7PZ*GaB#mdGaQn zxaHnMnX8{D#N~~26M*H(AB!d z2Qf(CYW|c?JPjMI)1)mz+ptM@%>Vppotx9W>bDo8g4kg^sXqnue}x zMYq@Z&+K6OUsu=0~CY^E#K%Pye9*lwb!NuhRR^Sz}sBTXY)FuUGJz{`~m8!E{~Y(DL_n z4^lb5zY+Sp>B?XMygniQ?+d1L^nuvWu4q99U^3!1a86RZYwJD7W8+5d>*Q{RK0|XT zLU6f#-BeK->XUn^o_y8YO_e<}7WaGq`BpDEYF{ETNj1l%si$ag-gg{oKCo44W(1d< z1-b6LT$fk%i(_4^ObI+kNgOANwKv!8_RQ){K-h2DxU79hC2zz%Q(GPX>`t~Fn%x{N zcL+8n_o8D{m!L^JLu(qN%3*Q=Th!VCB5Q)EF#DhD-uM0S3)Akm#&)=Y*H9*EfGS*S30>3u z5bRt%IiD~iL*aoS8An~Q=sQ(#=E^;A@gg_ z>yv4uV_Ks*Qe z0*D!X5>a2Y_oKBJi&2(_VhH-!B9|X)c_;xq1C^T;<^5>=h}J$-KjSsI#iEpVso2DA zj_Y3@{O<|sf2*zT9Reng%>xxnSPBWRJu}9C~JL+%2A$I zj0V|n(2|19l@iq=JOk)m~NYlz~RcQ}^*^bx)6T_C+0Zp1T762Zwl zFOaxMyA;*u_vTHm)@1OB&t7bimI8e^9MRF?5jq+we&6Z%(YfHBr}oF7)kz2pEs?aq zs~U&W>YSh88Jl0q|6ynbrIr$YAAMjyade-#6?>pLQtz1JSdyi1j^QYdWWsK4#a+Sj zQjignK6PB^{+@htEBbPn<5`}^DF)|BhUddno98*B33)zq?EdZkmACn88ZQK%kF*ZX zA~h}cI?k@?*nY-6K(lC4xTH$gETTDAmS2>|_f;qRT<%=AKUkG_p!UqeBFzXqr*IrCYD~0SMVm8pe|r2_GG;dfvg4v#XpV6YW(-c-qs%aHw~c_1r5t6 zjTg+wvX>UXJk^WwEI;V*Z(5Q&;8tK;QA|#)soUs(j)0gg+TMwG=xJti_0Tn=N$gDX4jg%G)eQ9d$pr`x&J>xLo)!Jc4N8a)DN9 z3CBrQ!9~l#Z-<}yaf{7YN+AafsQ4f7@pWB-mR08pviz+HDyJ4C)F^8JLaFsoKbk@F zodNwn6>2XEKWZgtoE(-b8;Tzj#gFczj@7UE^N%$`?&1V5F$^b43`yefJ{s$w7abbk zIBp+S?dZNkjlya7B1*~S_Vv!m&-41T@>SWbxmEAj>;*4$Ek?oL>$@f-4X@~!wkyNWYXU+^lGvQk%rgwi-TJ`fK!uD!Fw5) z!AnCH^{b;zz4x~N*|G2(O*T45Xd!+beC7J!XaY0iS7(PZf6qcGfEjVN^M1s4uy7Twr!JI_*PQlo z#BS1TGMJcKmX>~44(t|v4Y_7J6E|a z>5awqeS7h3Uw=5>-Dvf-9WT@Z2luZ(e?Ip7&i2>bRCreW<{0|Wb&Ioi=$zd}mkq|k zE!LH#=7_m|w>-$3H%^uPF5l!FDbLf1{<-hBwZFtr;_}toOD7-)Q~aAF%l@3F>joe| zTw2u9Vw*Irskk633c)JN#vOj=i4Omy!}kdAO;@{1JZVJ-&mRt{Quevm_C!1_1)OCx zMpk7>gip(Tb21In@S09L#MU*>Jo#c|3pGY#IYwYvjZpDMJ!Y*d?j|EO?%ths*c;%} z^KB6gRVYs37y)NRkrLn&yDqZmbB^V`98U@#>&KR*S26-?Nk(w>^K{Q~`vbRCN?w8F zQM=~lyH(%b3omAV@PN~Kw_b$4BU-9w6p>UHk4C*{l*5_<`eaOkRBT}z#UaH+1Qr7y zEdWMGVFB-tG9P2~a^Hs9LqMyry)8DD9RP6P^Mam&Sv_wLJz`;2?>mUwutAe)fyM>J zokZJ2tWnxuGscs-yPj^-3v8h`ESe7-pmq;*zu(stE4J(33;HJM{Ou>Jvn#g!X^1u4CS? zbtpc7cJ{tQC(-nB&+5afHk;YP5@`UQj+-%-ddw@1jBT zQofJAOtm|0U*9yLK{aRi$SAUl;24*br%e8+;3w}FU-~m(dxMh+LeO~$M))*qY~>eW zh{Jj0&9|!$%|}Y91XAQ=LFEOUmrzow*xhnfb1v(2bBzoAtA$IcbbJh4$+`%df(27U z(~RpXD!Z05A3vh4&jN&WHd^rjXBmRvd0dnzwbDDQ$G)`T&2(TQ9_zJTqTXwmU>xWh zg*dU4aeZhxS8eC)`McJ9V5@_i{J>R+%us|Tv5c&7Fb+(#M#HZ2W~Y7c<)d_gIX^(h4q0ETeJoJ=TX&Qlqg= z3K`q_&Wx9?Y4^&`2zLE~!1DxylO(}XG!3h6?A7nAQjmRY=y`% zx)fE-?|xfQb>Q|vV>@m6Cav<5aT4CK{(rfkr0q&B9OfbO&6RutuR7|dXV*<*vS_tRCq^YxK zYypy812?7aTz?)=T;d6rn&b9o`MvJkvHivTo~l1f7CoXDmMKq#YATZVQqG=>=lt>H zZxKcR3@#{|s46@|8@rFHWs97`_1Y|)v+w#Xsi&HugS7|*EigQb(+nX{Y?xib&a8&`qjJx!Zn}(0?YGwT_dEvu3#cn zHLeHTL89*P-hvePe%CcBD(SeiP=5}q4#4+j_9WwezYo2a8{<5ID_3Ct1r%Ujgx=GA zJr=fep}F;56;QNW^3LpOlN+{vzghS$9jX<`2EtC=?DncX+#c1Xh<1jyK~HfP zXZ@@n(>ryo2d2`+Vs!`NiqL#8u84Hvp3YN`uZ`PMtud4~K|BxV zX}dbBCMCCT^&wbD#X?poIWB^yI{$oh_r}}FaE$C zL!B!e9$(KLku^&-o>zE=P-vCI;TU4{ek)()rWfd*?4N^d)R?VCG5VT-l;; z;KW>)L^CSQh@?zO6nt>@PK_oR9OZm$PlvC3U(^lfvx?Jjq=rirDGEG`zqUVZ={L2% z!~jk8u-=K!(t|fCb-M)5-X(e-^y10%_(B7MHjZ+xKl9ey{WXx6c?3c89MAIrra)Q0 zJT2gyz*F#L9{)zLg==gm>S44~yRbjy`vah8~p4K_nH&OLI zA?!Hv(;c5XVM38g3Qd7WrfAmGRTH#Giu!h|b5He$TE5W{1jQO-*f%=J33i{9?;W73 zimz*4u3w$x-MPS_bK9>_kW@k1lbYc6U+#W`wI(^M^{Qu6?~WXUGvL#Vml&BK zIX30j9WRJ4P77nd9-16EkETWxXU1JiUOuxdawKAc;t7Q(0{&>&SVQF6EUL4rZ|6T% zo{HoZM!_joW+{T=1s?Va11`wzPzu+iI_q}aQT>L^=<|qTX@TGviokh}4mayOzA$*m z?jGwv?Ae<0L3Y^$zEcMvhDbKvvvb7!E?zNLQI$bncaGcdo}l*5^{ZZ=D*N4exg%CT zI`(w`*_LTn$qtiR!P*zCy@R2&tlD!ul&=*fjaFXY5=y!ObT<#nQsEVP|IKzTbbi0% zk7LNai>67Oq8WyxXqKla65hLx>IUT3B%$cdT;~|k!6*L(Zd42|9RdtzFc^9uf+J5# zv_R3^xfVP5!z0@idW_oAEwqZd`i;vc*3dM(3Hi?BZ-2gL@z)V$oFt{GJVQvLEaI?? za}RXNoQq0j`iJ;}< zFLmB}+Wu8x>u1I(p)GJ;_;%UMM~_AvE{UZXUKL54=fj3;In?J4 ztNOMRo}+7xcI@3i~CX`-I|MsW^2CDizlLMEyKZ_37XmE87t7a7q#x zk(OnNxp{4cY-g{6X_F@m0qgaZ>fv-Og%d8ncXE#cpV~WDQ6~*i zMa3mc`1s#%I^J~bKrG)h^u4Ot{3LVy%5}Sv%=x&g@W7lW6U_NG!JKy!Ofc6&N!yil zncI<6#{5cB3EP)+mE(=c&zN9B`2}=f;0K-gqw0RXq&_e~Gf*%9t|eSuvsHP#>g^%Q zqN2KTMDO_iVy-w=RfcaE*m6Vf+!Xju%k@L(W%=zn!wx#1~`VG37hwLIj!d&CIom9Zd{NwG_|ixO9w43W6Xc{w?5KkQe# zC6tC&^RRPU-k3)wThSqDX^9nRf+SRmK)Hzrus5n3?|Dvg-^rQ}GzJ4Xqo}$f5w(PK z9IFyCL5R|q13z#0YVFDy7*xexD8fo<0quQ$zBBFJ8(L>?2jcXNRSlX<<20veEGtk7 z;gSPrdC@W;pb6J;-S^x7S3NBq*PB{rcQ6G4@fCW_%k+GeVoRhrwA9~&&8BYFgMg&h zyR=IfAi>j!|IcoV{5{Yry+I!raP0-h61gqKxZhLt`=%RTFP~dnT9kaW=Vd)VCS00% zFK=Mtg^4F7T)FT{g3GJ%gf$`MHrDB$=VPP~;P+s;9QW6cQf*(^((?O%HH z%j{mjFG!_uJ>wjjC0)4%9*^6X9WbVmvsIr#fCC;5s|NXe!0BD%jMyqN|Bu_E|snLWc{jh&vn_PKjG91r&Xo3&vXywIQ zA1tMe_dBEE3{@+B+W7$UsclAmfRn}4ij8~+YnqDFyejjgMD9CyUCr97pU41rR2^at z^10mkXpLJ>FFFRafQN@y8W7*|f=rMk!HA4FEcb=;9qMdK0ps_HPUVdPcw8mE0V-riAD~9OFuW}}1ckdMy8YQ%p1g^JM1OW*Mc(n;cqd`{Oj1U)Xfi} zt&d2GB`As&ND60ohD8O$Y=RW|zvz72+bs93k7BYuVrW93X;Kn3N`|eEPTUf@kvpyn zF1mrOl0(w)CaiNVxM$G%SC4Vwy#yCdy5>8@yLzg*s#o;qdAm){6?5EjH@7c8;MdNj zs6M|pZ?a2)5oBM~o0<*IwwwK5oag|&8Du-c*B6Nc@9v`HQHQ9q>Yku_cX_5f^6$%M zEzg&ctB$fV&;)%4CcBwY7}WCO1T&+Q--BuTPX7VUg+6hXGa6dL5;UF}UxmKkMECu% zvvOz(#+?R-FJeB5@2D5w*O6O6)ZaM9ek5B=Fu?>9OfbO&6HG9n{6G{r-_3~kffOg}GWY94=hj6F8o&K(L{U3I z^E5+g3Lyz3ENZ8_)kGXS+ntj>v46YrQ{?eaQY1;y0z(rFP4i@!Pg@{dMuj-r?mW9? z1;PG8>Uo1prr^28(6p;x-bB@_dR?ACn&nqKZmGZO&(2f2iXP9N5p`BIv=2@Kvc>v) zVx@6*I;U)#_5E{$KqogEjUOdQxXQ7L$njEJ-$(VAFJ5}duSiiIqHS>^jMeg~^8-)% z8>jc7eM2%7&9OYmF%(6!0te6Qk~f3M^B}T{&zxPRZe8pfU{FQTsIm+p(mWTq15#ki zl4?xeGOB~euf zieO|ymX@sF{@T;hVh2h-{8(D#=Z}>$jj{F#`VMvZe8{=VwH`j%%wN%criWSw5qLm3Z8?s>^Ru3oOAwp-HkuRhVMh@6Xv3Q zRX0@=3q1ZoqF2o6lBY}#_)~{(IW19dIgdEoy(&6Ww%0};p*Tx(JVnz29bl#5opzz_ zSgdyns)lczy^h@LZYcuqWq7M_Y@&EJcx(<)$EuTxPEBIQnAo5%6wjb;Da+$Z`F&<7zc;06oMD=|}+0+Nh|2E_D^tXX7j;Ub{<=ye7Gn>mt)~dEs)?>6xX(kMaU$(4-Ue zhl<{@s=rFFu^IKX`<g_*&OJ<(9}^-$8pP7JE~9l;*6X%fDgVFP zAia$62<$&|^%RJlfIqv(5c`rHQEu`j!jCHr5~W%Ii&_70eMd8n-mS>xE@#Uc>?N{iyR8)MjnzPGzMFD&H(1{y;{bi{Jo@jGcOL2=!M`#mkTgLP zJV#Ojg~L?{?*`M~5WTQjesa#Z?~fJvBU|WCRvN{Y{%ln@994^jX2T^_V;PF3DHVsErPWJ|w&G4X zvkqmp{(d5;V~k-Pyh^jGCh`(PQk!OeF?#CpwZ-r~(YwGOPWq1BUGDh=EK#E{a5U-i z>+J08?Cwm(3graTADO-1Uq7j6Ki26d;2D*sSe0Q2fI9v3>PYYOZ1=DR0+KVtT$HC8XS!d%&2lcZ2pw~Tb2`P6e!q`B-Tr87lDg~XTOa!Iv$JU< zFk%BYFJwoMVZrdH{^Eof^NQVEwnc)17`^UF3M~)1DDWY40w$j}7s%(ajF>OSc^Ux~ zgNPf)^L{{zbs^Or(_nBOX{EQ%eEmZ7qq;S)q23VCc-jh6o{I9ZUdeQE!8oi?I;e?^ zlVTmeYBbF?4VA9({0%VRS{~oV_`5db+b4R&U0>4GRj-Q;Z(Swz_*B2WU~6@G^l!YE z8RGTZ2KC#GrR3)($aCCbid@Y1m;1Q5SmmsAiON~&64l3;M=#EL-)uUQ>0RIY$mFds zjz?C>Hi{=#(L4Y+Jp@J3ti%FA;#5b&0pIUk(=-K6d}A!37&SqTK}D+{4f$CcI?5(qU`qZ7I%dhvqlayHYn?zinyb(lj?%&)OUPVU&gzE7}~wq!yR z+v=T(adwf#`fk-R$2RPXx(Pxv0xOdmMF|qXZGsfraakl-ElXGYG;%JC1h;4YGI8w9-jqb7$}oyr zLxc`*{0!^I)qXCTdj#6Wb0TG_%A%rDB*Sq`z#3omo5u9qoBvCI3_Rh3P>ce6-n%2N z95$=Er2D2dMUBHnK}aAlx2L|;D6v6T>I_$XR`EgUMb&*UPV+`Tw^TrqH zRCjwz#iWxJVNW;Es8y{4j=nK&p8&V1XGPeirUb^RxC^~LPqE^2djKi?=^5asD66 zo@DSx>Dtj!PVZmnJbkT&12E>P@|92KQpyAKHQHX6n;bIMy#^TTRztoUd}M$D1{e?u zxbqDSf@DxyMEO+HI=8B$x$7kKbqL*-2KjRJM~dvsvm@X9 zI_pq+tiuuYb?14|V`)yDm4Y5of7NS%3xQ`g)v>-cYUhIAt44{k$Fe*pGQ3Cn!c2&qq89^RSsC z<;g4K_a$xE%=+KK zIc+|>2Rhtdmk`#51vJSA{1XlYw-&oRpsS?hfu5505wG*Zn+jcN9z&p9)lm1|0DBKK zn&OItlF{DMy7t9yudiAS`W8MME|vYBdck<$ndDR{hGi95V|j|`(x>IuPfi?>UOh%u zi3l$3|K+`aL%++y7(>mbR@U3UI5n5s7S&lcpcR^>NR^`$7UwMcL<+9;+gQ8NH-56_ z^ICY_!5=Y{;zf!i8BUYQqeqAT(XQs(NjR0EYAKteYMD8wopsfLpWnK{(ilIV2kSkW zsu4Ud0FETt+`NaM?HZ&!tWAiXS%QhMKG67OU#C@AU)>ZfP_#b?Fhda}L89u(UoQqa z!-MhFO;{Hm8?h$)CKv^<0mfmqE8hn^PQU`0QW!xINxra7pUgsKMq)jr?0@}NHvWwF zyEE0}`#;uu{qBzZoHLc~JKQ)TtPNH*&3C%f!h0@XEq0Ous^wj8iOvib6KUPtq*li} z)8VL@o)A%!q)CYqWSOK?A$!!}?Pr?KOUl1Stq_J4<>IujvAY&|%#zlHH$4A99s}o! z?HKWzFZudPMNWp}Ig$mMNbt;tn;JAU)$L@V^-mj>^U3yvz-02KOiJnr$po8tjqP^f@DTWc@5 zz3ZwB0x3w9rvkVQCc?nWdZ>~)`v0Sm0#_pgcvtVxKQi^=X-FKHEz2V3lXI0{J%a6k zwnvFZC|Y+m`SH5dJ75Rfszk9I^mD7AuUjq72RR;h5%BmXjUt=AwcB!+Wt6cuV}Jn$ z7+`<_1{h#~0T&IDpDV*%gL~YyCTw0zty!G_ zjh@p|Lb1sdnQnpXj^Kk}_q6Wld~n<2{c8n%X$srrV-!tRWldywjzIU_*CgVq-OK9j z)AzKz3^uF~Qf;5)Ds*~Oh2bck5=aT~U!55|BRJxAA_j-&)Z1EP$%nW8_9fg{o|PC@ zivn8Y^l;cNPha56bE{pY{QSprJ6qTNIWqlz*fo^{I8U!$R-@27??lQ_+Y!!ER|CBA zZRF<dD2G^B*5^jBGMv< zp7hyg4#j9@gRB$YBYnSq0M8-c7->EdG(lwu6)+kD_RL=M8%3A!}T(A#fpa^yS{Ohc{r3_o>p`e8Ur5K&Jw$ppy@ zJWvQ#5gyyL^M%Ldr5Oz{^~#U&ysU?8@=N(%yzeh)Shn(@-{DR;4YfAinp%`FI=-`G zJgYDYp|QNm$-}0vH%B@_|bI1A7p?ObYtf4u~x=$ML=@-vnFFueQOEWA_3p~Y&B0-=!w!KmSKZ?y_gjM_g z{*}i?Y!(#7bD|*76i+cM#d2sC2|9nQvf#29V?FTTFCS!HUoC>zECdsr9#!QeKv68A z(Cn#31Mdx%E#^{B2$FS0r=$PAKC4!^`W!6JXjbA#mElQ>N&fKWJF-?Uwn7EEMx1#` z)@enb?`d#X1AI>7rTk*x1h+axPGV$2ktm7*4XRiFqF&_z2{1nv!T7o<);}^H8)YkQ zsy`VXo?`(+l1^8l%h!D(P>Ox7!rUCU*X47$3tI^T=ML|6*qnl_S?cIGy^Kw+SRd)T z==M1;z!^9%`V7o50!>RY2SgPtOW0#=_G)SxJbzg~A+#v4C#oRNORFZBP2;S?Pp<#v z>zku5*fdoI6irDCPo5qgEDDQ9lJTbA+%y9$7(zgGGB z{r`PY&@IP6?B_t<&da<#oR&dQ-6q$EdO<)4U>~O;x9IT!}ocSb=`_>_w_%B%}!u7p5;lAlm)Tb?x9mpuC7)Y zT{TarxV_4%k7~g&a4g~&5LrTI2u74O6}&fQ z2H~93&I%{eKcLY}XV>|eq0)7n&S37A0sKMh0B)`q;l3#WymDmddnks`PydeAhwGZ= zq5rprlZ^R7ySUhzc2I0`XJ_oN0=&RW3`Ix`Nui^-S*f#|YJGd^rz5`|T|c@8TObuV z6;Tsef#(HMWRHzlHFoBfchXVyb#OWD>%~f^wE1*Ja9N?NDL(bpY?^MZ^vIFp#}o0Y zA4dqRDDu4j`U)j7=pY)eU&EM#of&6Z2fcsOg!Zkmtiq5aO^BK(QLKWpiuyv}S8nTg zXRbS}%WmB`fPO9dQdW>Ci3Nh7Xc|#v-(MCfC{O)3ZcLBxFwZ-zXKNKJ`JY8M38*Z^ zX(Gd@vWl7nhNOhfYO52X+aS!QyRFx~BD`{-H>~8u$fjqK1`5fjDx-oO8{Ylzo+VTU zoR#5_XcELCk-%}mv%zd@A~S-!|E=>^o+Dm{QDsJxRe@tviA+4HzTM%QuM$QfY0gIO zM%@BCO4py>9UZ`jn}%wNP4%g6zixV&u_}Obbivq5n4W-e}!WF;}OdS)n*aA3v+B?BiPn@a@wAIm}-ZpjWgvhtvZHXY>ZCtM~6| zD2(O=@C|x9yWn#3-9U%ecq5b#QhkB>b=Pa5i~_%dH#2V5)2*d5KhrjVp&C94vm>#u zf_=*3#q@pFmgKWbYu3ezX<8&ikrWA@B1oR2MN~|mC<^={lW@cI0qg&{5<8H8;k7A7 z5Ew#W36W+*f<<$fy+c=9v3pwctrO2?|1a+ss2fMPUJOF>k(MQPj>O z04Is6Kxza@qn&5Q4x44x>HGFKvTlfAH!IN{HHqOEk|YTY(C~PJQ=R>Ai?=G(KbZz6 ztG5yD1f|P9`#fzOe%qqvExJUvrfQ7D6O14bB+H@J)HibC9f_-~x2ER4(P9|P>u|)p zB#l=oiBK5bW8P0tal>3Yx^y z%jrA30D0c}(=#UqJ$NSCX JnxYV--ztut=9&I<0KfB8C=TCLU2iRz^7`2PJy4z$ zMKVK+wA1DFZw+*xsDL8>w!q*?MWB`Nly~VdF0m4_GOS)fv+jE9>&JFH*yPqWI-L_< z)IfPj+S%Fb^Iykw<^rE{A}u*3Pj0dQ0Bmcbhg0Z^9z=- z`j&@IH%`8=CjS6yoO#tcuI+RG9m*&0ijUq2oO2K;kP3Y+Wl*71+=*V zKDP&*@eW{37jIY}x$mZ}zdVKC&-9-c6a|_U1wjxP0bOXc$qW1%ie1WVw%)(zfmWMe zjB*?#AizAnK46kl=4pafRh1?P>g?IG{qI?olLRx%(TzYWlX027Z5?+1>K$DN){8cS zlZr^Gj7AWG$~nFH?g?*Yf7#-A{o6895P1==xAl0P1X)a5tY7WkRrl6kqIv9_s1W;7VwCa<~AbSpNhvs0b*<`I4Lu zhWa0M}aLkx}3u@Rip8t5%rMPD!-eApDx=vG>&-7>!S8nui39M#ny zOA56LFRvW=y)fH9LcffBU@s#B;**=LF{x@UV z2SSYzx-ojaK2z%FP;Rags;%GgzW~nE%UMfbP9nafCYn9-B`;w4MfESaP1IhBXrwkUZrqEH21)`B05)&PZIcA6a`1QF8a!!Y`Nv znk7Y+q)A>B1U{@2dsm88@{g@wY<>Pr*Qc?2KZ3{#Bu`NULvoZ5=DhMBK7f~ESAF}e zi}v)&IQ2^{{9@m~3G8=O3S^O%2sxW<&|&kdcV#38ak;4sXW>dri~Fs&FU;%vz``5D zc_LJUrUd6;FFy!)y)JiQj>nzrkqZ0@ue;czfF7=V&<$u(alS9xC3_^#r0Hvg{eBw+ zV)8UOSs?q`qn#IG<-AaIRXigoCIi9R-~|V1V_ngAqk^&c(;6NowKtm$sd9% z<%wY|3kt_Oy>P)#^CV9Zyu_1$JNsbfuk(BUn_3xDtLbx-$|T*UH;cuspII00UAt&* zR#dmQvLrLA!ceRt3OKj7tFT!dwc3W-I+?GJe*94(2~}bgK~*IMO?x3W?eDDh-}F2? zdszd#g&QuHosy~$lqPYK!fVqX^u4j_;5@87F0qu;&BgL-9RJGsn04^|F6Et5wZdnU zz_~##FeISDwwKmojRwc9lb-nd=-W%88-GMflm%Ml zDN?<@cXGVt`13cxR8-hcE=(0=bb{o`9wmzPR; z!g{)Rz`CdT-~gm7@48AyiKWQkKmmS?!yA9;5Us$Ro{T*fsWET^*wvC=7PKF7_WxV!;P z7cZ86x6Unm@A&UWVZ*PpL@Vg)uZ3+8}&2=&1s^l$O6w&4E{95^T@9M^QAm| zgcm3OTF0_)ez|TMJe}DfLiienCj%#?y5>t>Z)fkMLZz1vcqE_Ob7qk6a_w)XRvul( z6>=;{j`RQIQhuKt1Dnb@-(*A5T-6Xfz>-1+*cq$2<*XA=9)VI|Zn#1ke9lx-2u-9o zUQspT>6s~=7xer$6(^F9>Jr7J=lrHFnGWmpI^7VGqv!p^pON)v{a%kLLkRre94nJe zwx2fEIn7jq%EzJ_5tI*tae94j56E^aQvMKs-Kc&)-S$E2?-G8gAXn8xE|O=wRx$o> zewlD%%W_UnjI-Y|DyTlHj%QrvQnl3u)~~#vw0xL+k@(0MuNSwSuXH{(`2OPdp9wK_ zmR1`###P0_mCip`8{hnWf%#a>S2v%;TfZ?CR6auvT^dL;UEO?bx<>e_teY~^DyW~} z`ZDJNzsJ=Nu5;mgKO)~{Ap8-pzB@EVyX2HIT{J!I0^0?qGp3B`lyzL9`Qjkw5{<92 z)~mV6fQu=Y(Q(zXg5+bXQm%t8l^jkeCpm7wl?^ix457rJpJ;pZugqO9ME3*$G)`t% zPT?6U?1~VNO*+js^~2M|b+zHufuPfTK?mbRiDhM$kYtUCcol6-+xW1_6q%0YK;M4; zzsj~D)+w{5F;NdZ@*2SqibnAoC!q%(m-h(0MT64eO_XkHx3fj9Cx=Bp`Xi780R)~> z1qyBbp?6y_NoUx=L%et1f6-k$kSYZPh2$tDEE+&pY^gJCOIDx!xOOkNqZQ$ZmH(Kv zA{F_HJ;2FoqTd$*$1tkawD+1fik56Tf7Z&C7>Z5E^O;B?X2!rcC@H+%Hu$}Tt9snn z5K%2cH|0r^k{DSLX@9^W2?M`xm4SK$YG1a)twGIF!#3Ia@v^s$M!OSEaimPKG)?jvi{1%uh+rEwr#d$4 zfxTO1R%siaQ|P&8mSLRP{!<6Q6F7a)!<#LsD)9KDJ$yK_=Bi+awM`P@t!YEsffcQP zQJ2G-9xOSy=E+qw5AgRtPlrKE?VIyXWOE+suEPTFE>W;?pz zjh9wUj_#X}U}%QcXq9ATs!Fq;oxvVi(@Htcn%TzJpYr(dl~8gn3O~CS5*a`uRGK9u zk^>GS@<-00no6TC;s*0z7dfXEAMh2mZqAIcs z$C51WM#hWSNu;%H;jY%nXTOQ=gNRURpa34IoIs#Hh-xlPj&s5yY&SmRd1DO|bHb!p z(V3m!y};%32TlM5E}tGSUh??7=!Cf!8TS@!{*+B=sy0~E9_ulcA_Q3$RF)Aq2KAU~ zPb^*EnN5uC+k+|HR!oVixC#o%QVb~qULnz5>w!(0vlWf11U~QC&=jhVA!pXXc;K1j z6aKSDPP+a(6S<<(0B}Ovin9vF~o0O}uS=f97b>m-x_XJSA`x#|Z>O zkyMz+N1Ffe(GiHaa@Mtd5$AQg5wC5=EFR(+?yGTwL00<(Z6K= zRy!-4wMrxv#XB_@$XEM-FnK`VYr@FD8*B|$RCE75GAh&3ln5A>BWXsG(WEP33Vnm^ z_LOA}ocp0~*5H71K98gTr-u?nKoK0^8A8gDR}yzTS7UEg{Nk^G;ka`b#*+W9eb3<49)!#|=}gT3@e7l#wzd!2SFHaGDqQev zCeF#HB#9i!3NlBsJHDyi^y9Z5HZQr#Ch|0s0R|XgKrG?e-S*RSZ~xM9YrSZuGEyQr zUI08V(c(D+Zq;uZ)4@LQKC*{m6yWo_v7VZ5vi0n<=$<;C){ADC6-ZH|7(pczRXbOX z??=r3w8rYiR+#L@ZqadgzI|-p31hFb9Ev)rGYqB5Briw=6BeJR9;Rs%Oxd=f?@lak z{8$sb>92s~S!bTx<@NP&6-xO%{5r`%AgSKg8*Z2yYy=!=j*OwE-#^aiG}*R&&n;;= zs$+w21uWRJrz#csoB{_3N#aPEkQwymRTq6XuFEttCZDI8FZ`x;wOD~_6`B%Rf}?~m zWvS07oD$jJ)~wG*DR-=c>e8$T>Jp_;qW@MGDT^#U>-$5mynWt^x#`Q4h&b5R73@>f zg6K`C)iYk&Y|61c)abT_ZxvwmYnCD@LSzX+;7M8t3w%N7UiWXnUf3OIOP}L?wcWm` z+$_=xBa;HdD`J>4>48|MgM)4V`=#AD;S+c(#Ac456S7W4%FiDNG~n?&+xGU?K7L$0 z^6flZD(aVF1L9nI_{8{ZRH&nTG#v=rkjKlBz=diBpEAO)vWD1JPW^r1>NLD#eUhOm zhG7Xp;6+9ZbA9sft$|;Av3)hvcFVy-lLj@5;7(WXDs@t!Q}JK)a~65rMZn{mx?^?DmdRA5ft@+Y?!y2@(f*nPVx5**!LC z@4N@-a-NfO9L3TUD(m0Tf6O)EtWt{Y<~Gw$y}C2Hrp0rlNJ@%K zkXqOwfc1kSYg&peb=ORxZ)SAWSkVYsW=Vk(!;G{CYt+DqQ(#N1wd`YWa#Zi+L2jqe zo#^N4R*Q(kb8^{oN7-(xGAS-|u*CYa6i9*Mv{>fgt-V4q?*GyP?z@o<%V$m-8D|7% zv#G$=DebzoXQ#y%!i4Xg72_-cEz%;-Xe40Oe>-RJ!Dk5)5FA_a9B;d8?HvG2 zs~OHHK|+|7G)9pC2^baKgPhkm-mE6tnzUcRRsXJW_^Kgfyt_T!B_+=(2!bSuyezAn z(4xbRTb>^`#fo~0t%|8A`n>8zI=q@)LFwS*aNKUYdrHxLhaPBv=t99GPAYPa1CzW? zPL^0%BmmG8u#dMdg?)9l(f_tO8DJ3|KRXBnc83DXUFJ1jskegD6{^^2-Wh=v7 zwom%pIlI%;Xv!ETGMYrnq^hwBI{ggB;BbDp&sOuZDfgYB>W1f3GW~FjbArczyrJ-% zZxJsl(Due1i2Ht9Jy)-e2WhN_X%&~P|e*c&c!1?Gp5oTv=YjG**b@Ii zmbtdu&B}tCi=v+L7YUUYHH{%;fksdHzdA0^12^6tudJDG6CF2pzv)QS^JoGus4Pos zl%}b;^Jw+3SuC)bZn^KvNAHF+#jK=AGlk46jKBya2PAD_^E-2AZ)=+5EN6~a<2;Jq zAgO%v+Z7|7%9n{GxX`eX%`Q?oVSB<*ZP0V{9lGItMpEQ*&DZgRrOa>Q1(vtG_5&tb zN+d<{xqvE_LY88Ah={q_5-xFqp+*cEwf&>M(a}jCHFIRd;Pc8c+6kr8FtP(<^|8p- zHuwFWn?AuCf(eEtXr7`3ffi^!%%^v;{^J-{`FPZ}YRNLH8XHdxO^HznpopZ*$SfK| z(-xzVN(;6M5@MCg={wxo{ZZTL)#}RwQn5#(1&(KBS&}qKW1HWdjfQJhtNH(du;LQ*voCy z!afUE|BF3D!E*#j^Q_1UEYH$myXQ9j!|9kq6w7Tt^jiPP>18n8brBX^G{ppNtM&Bx ziUtACc;FfADgf?cUuUn^m0ReK6FSm1vuBMiSqW4*vHNp;WNbkBtlrF~Cv2;JJF@Xl zcZ`_RfYbmB7>1|9g66KdCon^9xHEts%EWQ;3R|TI+HKtRe&ZMmHr>{$YMP<|RRAi% zx9tOdjka8ySta`OnN`ZxP^As7g1(PiuC1^&xZgAW=^vvm)) zuX%rdNp@+wG|3w00h;c*X1G=fUy}C8@ z1L>x~$h%7)fDLr#iLZ8ue0*(pVracmb#GH$bY^I#`xv-U_Z-tx_vE^HVxS+7)eCUb zCvOKb9F-k862{6u0|oy-{rtmjy?o2{^l#O}8LZcf`MUnyPddF+_j}>c%bWCCX!_Ud z&-G?9JyJhVfoB#5@||wjBd%#R%xv0iYnk`;-@e=6+`2B}+{&{wr;#)*sJyW8B-6k9 z(zc1v%|^2B`*nGf$XIJ}aq5(f71Vodzg|D~t>2c{2(KdyBF0N3A@Leu01%rU`QL`$ z>_R4-8BR1eN5v2(206P)I2TMTRO@Jp6u7)-v*|-yqLB7utEOq;3X-Zg$?!mS&tapA z?X!9R?zE=EE;y;pHAS7&1X#e#Ol(2iYe!=gaecEWRPS0xK|t z$kH6a1Hhmi)&iUMVcX=R9cniED}v&auX>ym=PZzXz~hqgU6X+`Px3a}G~%h?IErob zVKKxKijQD)W{c^#Ox+90+V5a*4B@_KJTIs5+~U&`m@ogY3v#VOnS zw`DwQ+8@O+Da-H-BTzg+Q5r{NZ?HHoBH1_**C z$PAA<3WX4VRD=I)|4eN8*_I`EN1-f1P&_3Pv`DZl6&6#hlOBxs2kabq#>TFFP@8fa zoVANWbq7jx%5HTMTkFd|{Bt|%P<0ow;Ct=@2UAJ8&f1O+G`-oWZIp0oJWU8ZEeI4x z5Il`my>mg}*XSm=EX?*L|9;UyeX3zJ^#F*p#!H&4X#xlRxYwGnc`>zSbwXkc4Z$2` zXqrRJLWy=d#XCQ7cCGN*25AT)Bl_)I3N5Ju8l@LTV@}7kXrleS%EM|N^hVEtP*}hy z1O-Tzpa1DVq0_3g^IGiKZL#_+#omS3xUOpx?C9VblA%}yP=ZXMw$?1n1Y^Pu`gHr8 z4MQeBwF8@-#tR}PlMKrWB$}NGF_Fc}F5NzQe4SoTe+HRlctpvj%8E)6G$F7&F5=_E zmQaks!_FUu~Ie84*>Px1hDkk9Rra>3`t3CDw@ z4)sh7#qkeStG(@ve&5%rQX5)*k|LBt;GAAX%9lLnf?s477d_ClcmG5fZRHESW+R~d zMhrgCtNan&j?$$;eBVKsfsso%W`oab$7vv$g}IQFf@w79&3s^->90cQMhIOE(@q=o znffba)c*qwZ%6}tk{Vi06rAPMuJJPY=Ac$!Z1Wmfuw0!WGNtVWR-jVZe#6GD;ZsUSH+CL(n5L}-@{L{ z)$H3g&Tm+F93RA;=4giF{4VHuiXg)@(WS2j521%lP}e32S&{JF!SH1mHxT7R9&keP9$(^X(+a%5bPY zsTbx!OIgd3W&dE^;BVGQBzo!resx)6+-$U9XE;be`x{t-HdYT z;Tds@$!7MSK413T=U+#OI1;>bKnsjau#BXz0L(l)^3AWa4y9+rC`{G`R;F^yS+u!* zeUh`WJrqRM4sZpOk_v&M&U47G`DYmQe*Bu&nN3Fk(ild8C9ZKfud!u z(a4E!wMj@$99T|08gER!RZv{vwl#`-aDq#4had^=?(P~Kf_sq0-QC^YoyOfgK%jAV z_x{=YoO|kat?GxaepprOt5su;IfOC0!S0JiT8;c@?;==d^%o090n^zEsOc zJf8~W6=duq$e$3NpP6N3w4+vnc`q35{M=cxhl9&?tT~BZrggvh6|T_U(M)k8fS}X@Xi!Bb#18)pfT{C*y=eAd+ z|6xo&MYMXJN;*Do>3AU0w$VTL{!TTAZp4D+yT%8zmnOxkE11?d0eC$5zC@lq3b56o zDz&TvgW19X=dITSwy6+V|MDFwgaj_im*2a0(lks(eA-#chSAJp(D)yf#d(hFJWFb!+sErLw*(V0_mhqLCd%mm^)c+V+j^R!T z|MQ6O9B_ok42;@qj!<25dp;= zZt9_*&0>m_aAS`c)(AY5uAo`p&r-I1|GHOebOu8s9)C%*I%wa3T0DR|SfoUBYTl8C zoy|-qBlwyYfHopnhh$KW223vDbvKii!Q>Fv;F9=1E?=RVMCN;_5du^LMf6%84vOuM z{lDo@k9RA;m{X+o@k%Ioj|>Vbo@JaHt(=O4iBY?;{Vanjm#fTo=(CpCRCy)$Wt0<` z?&GePrMi}(0(x|83O4M4cz0Ae1AL<4En#BOKd32zp=-CpD**auyt_7k?zYd6EeIMK zRbRzlnCKAAV=G>pxlHb+i?K?Os#0bJf!x!N<4Cv+`dzJKx@Uwy@9RypL}OWT2QEz^ zUj5C!#0a6533xsgprLQR?>Y5G9Dcw+r%H>v{ojo>F7YIM`jQ#A&YW4S z?;k8oTR>fX1)nCK3&_&7T+8)*nG;X@85%i^Oa*7J4q2I;#CZ<`90*}6dfnQ&=~O_@ zhb>e`%LjBL{cB-VWwS@mE<-Al&mFI~31sJw)9z|mK>rxm=&rI+fpF>0@6;9d3;b`G zd`b`$aTNi7a1B*Bc|y=9Iz6f!=*^0!sHZNvQ!_bu4td_k;MgS)xdGXr;~P{Mnfj4a z0yMaNX>q@t)~XqQ3VAk5)0V128rZ~(2qH4D8W_y!gQ}f^336v8z2klI2I!dnW)m;D zm5T@W2-3Z{$4xf`?Z~}zSHGSPTV~)${e!)+tx>9)&DZWfJdBn(m~{*rPp?H+30H6t=X+7O zNCr`(ci@PuNF324Wc$yS;l2uDyyymP2F_km+%X49WH;LhA59^2!{pGpN*FH4BBSs?Nk}Amyi2whoWDrqhHe>OFZk01-)(`TlCeMbfH*}XFoaQpDt>4w3@!Q=mPRGALzb3a<0qhFXR zLQiWt2x-?Y!_!T*V!k5Yjb1CgZ=DHMsbw1pK3_lVV`+#bSFrWTQjR(MVTos{$@kD< z7y1drQmMyMT;Q%y+^OunizDzaVEgPWq7x9m7NYA2S(?ss)j|ka;s@Gc2TGvrtwag0 z2pye#x4bI>3_k;)Cv(leNvPEAq2KEQUfiYW+FmdU<~QveA6EdchuPwCQH`OGbOp;)xGFs zq~J14@KOq-W%jg1#HOxcJGgx*f4ohrz2?S#dA$$M)bdK{jc^6|62vz#M4Z8^eO%R z;iGHi&@-9j&Hk5n^GD0glwY>7dD{uhDu*}uQD z8CnUdK8L;{EsMvs3JX(GYQ$N^qnjmz*a7KW59anrlXbS`p+oeq(21IxZYusLsTp6V z9XR^9Za1*}O8-j_ecWi}J%wHJSO|jOH^yA2sG)1fy6>$+sm&I5Yu#v1m;PzxJ5`Y3 zox?A}>x;tB7y)HjOu#?rcH4fdOusD^1w0|2k1)u;8B{8tqO^4!Bx2%NH+MTcxGt9S zz41hwN@?sN#C+8XF(2sv3Vu^D`qYE;nq61<>`S@>+pQ=Tr6c=Y=eK4pv1!;C84&m+ z%k-T_4d3$T9Oh^541DD;@nGF3W>&H=(#;atpS~;2-Cd`!&#&gh1M81wOSK6s z%Dkzm-pyn$`#WqWnP266YSg>AxThc3@_vnI->7erq(t%oL-fqv{3}=X*#sJQ812W! z6Jp13_-bh71of&u@Kl6Bgb$evgduvyH?yBM(d!7(+Tk|N&l_=wv*hsqUv&HbIl`!5 zT}a9P&gowfb2nNgzCWb`R%^i|JV=?90D=>=1jhiVRQovcec7B3ae>rMrEx&*^V9i1 zifH-OmsD5;;4CL4fe#IaH0gZccaDgOj+P-~)hw4P;P*Tizek;&L)Tla1`DxYj0to`W&gb<66hNo>oG&Tx<$Sh8(uor{DrT?#YP(- zWs*S)75U$#YO7{G61AHnE^fu9d1t5se|v|{zE~7d%v9Uu-w~!4)7NdES)1R14mAmU zInMPtmLkU5z1En02`tNJ0{ey?^1t{gxAXV^iHWjY0kCz*|EdjNnjp8>K6LT3v>Yuk zSjS<7A8@6_d4!Wwa*Rr!t2o6E-Q~RZVz*qMfVU|!<59jjq4d=y^+v*kBITFpL7?@* zTzJkfyW48EPOb6qylb?HF&W{_m$&&#LY|=a)LuA>k{ZTq8ntRLnaPUQmVu}weNnef zqrkG6h8~R<4W*O}V}RdPIGa^{0h&~n!KK>r(Bp54@JQJj#o9)l)FVe7`VW^6wF;f> z9ipYBq4EJWBB?WDN=dxW%iX>|4;}nKH6v@Q7C^3o@n37UhWDTD5IYYT9tuH>aCn%$ zbYvv|k>WdOEI8R5y{*pO!skxO87qt6>c7QVGA-X3IQTjA^#t_C+lee?&s)4gh^+;H zI-*?<+mI2?0kZe|+??TLR4Q<6N@35rsC;Rf<<@X&BJ(>b`=o2#x+GpLkq~Cw{;B&( zBC<`?(rmI}^Ow7rXiD}aoV}mM;^ZS2#;|)|s|C?~m1HIF{NurtbFXtIKwJL!@FpwJ zWX4FCVLt>8xoQrmEeL30YzsL}$HX7G0KGrVs1P$;WI_k#a!N(ehM9^Na0OGDLQM0k z>VGbSBy1EHX&u0cZA8)reNr)~JO-7>_3;=wJ6SgcGx(}ikb3$6fkBd&%>a#jkZ9B? z$LJvZ-Lpf@rkn<~U+n@I6zSc%g4tmjSWl@G`Y{j}p%o7fH5rG6?pzcz2t0)2=wdHIY8KNL<4Rx?xM*wdE>+vN`#upg&$IlKU>|%Rd)@oK(3XwzeTaLi? z`dA)uUF<@!D-0;dnHr%2p?BKd+n2Ko?L%LmpQ(dpyzvA;F-^SQGf~f^C7CJ;x6P|} z(cKeKhl)+UK<<91Z^CrkecF4F;tB9~iErB!9g3gWSux?ZZw>x*@BKqaVV?f|6mY+4 z%&H<%R*_G?E>P4@nqCM91(G6XqDzDvkMtkHG8_Q3V*C*{BaO0{rUHrtvFJbsC?TM! zsJT8%-opKs!DoFdaL?ky?nE(P{ne7jr48}JFgLRR{jOJ}N*sicc1hLer_J^i&UW^H zFMZ#pRhPw_Ss(b*aza;@RBWjf8i*Ol9LYzg5o3x#l1A{4lkL>lMgQfv#VZQ57pQ3T z>}-A#E0srYC5TU{m3IP~NA`a_fwP(!i?AqkYW@fGFej6#>w=w(*Gg2Dh8v|c?ZsxR z*j{(M;EyV9Daq>aF2S8?r56yd$nkjCuU8(Gs$&HHulZ&{7ZJ1P7#-p$9grdx-A9-v$Okd)Ak0Hd#;joPF#8f+f2; z9bdxPLvf$7m=r->{)EI=uMc6CJQ3Vn=nSJa9XWPD1;OmX^-0zeXpT%coF=j8;+s*IO8w9lfe%X8reol z3TMA$DYx~3K;AE(7R#s~?dmKl`&^MJVN7c?4_Q15A!@GTg49&d{_$d8%M#=YMvCmZ zJFT;(9M*EU&z{Y555@Sg^PMo`taSDfWQ5SfDTi6fLoBSE(hQ&9OLN8B1ksIqc*y#> zEG%m6(_77P;(bfk7FOR^$H=>XMeSLZM4#RFVVdAgxW(Z7UV z(YyF){HTZln+$$l?lz=1`aOheBddals0zGXH$4<}fDp;~EiHK!${ZC0o%zp{z1a8r z9)4qCB8NU!teu=c3B+hoV~u7T@RCt<-i?iZ=F+7+<*c6qw`WDdyV2C)PJZ2!WzW+y zixn!C_Wm>TX(!)H711@E`J7aw&j!Bs?ESkQ_URAT6xH`HZAxZ^2_|xDEwJaUB6IjI ze6R`)kk8UL0gbXiUHp~ezsa>wGgUOX?-wgeOVgz4_>JAS+;6uF{^5Vzvi+ib6-MGv zSwzf64pMl(+6n41{KG~sQd43pjPD{xt{^XH@ncVRSdw)=d$a8?t^J3r328h+q#a>_ zU_hp2kf)U)rpP@#5w+xpA46~RQxMQ0dNA(Rh@o%>h{Y$AxlSlmw1BWnDd`c+zTZA{<=U=iK~kh4~vExiaT&{CE+J52Q73+Glt)JSV^ZARvOKFnh2|SO};&qniK%@Bz z`VWAgS;6q1*^r8m6_m2heDXI*?2ze@2^b9fAIvdBj0Jt|0kHDfwGJdT|6Kk--QF{u1|}47;_NA zYY1NPIXu5FsP5$m$)glcf*fGL*q<60`wu$h$sI)_2mgjhXy|kM9?fyDnb0}VOFw{W_D?v>~9z|Ub#RWk&tN=VIO1MbV_{a-gY^J{077^hZVri z?=;!mW!9R)AQC)?1-wMN=jBZdAoD03a3$bqlZ=wN?wwy&v$iS_isDRr&s+I+3Z zs`h{VKJ%y%XS7aQYSfrkA29TLhORL-k-AJ3~R&d%W#05gr8I`~*ICRhMYpH*VBTzlbKoqGo=| zi&!q0eyc$FbMTeB!lq#;uNp_r!r&JV1)P3+l1s6Z-ONNaKXZ~oPwzui>W@qwo{#VE z?AI~P+S?Kqv4&HQ&&|XkSg^v731w{mi5Lj1ZrXnvJx#)%DI-=`G1J}W~2r@hfsR%5bKkM<1 z$9=c6dn)5~5x#;3VUI+=bzl!8HS0RLUj$}YGWgH{+`5#o8HIQvWUvYO{dYZr5Ac|F z$zi+xn=$se+0KuJl3T@71KWH`y;oTa&|ST_ZRn|N7b72o;nP-7Dz*EgZa3>ZyFMj` z9DmDqiHd3}?++J;q_eTC8kq zB@?zN?=P5d#V=<3V~V5RM@27}5L!)zZR07pdSyA#@yI7*mXI>9j7D%5Vp%Odimz>< z6n|b%`zDO+=4{bV67MCNY62&Ij)AoD(8~g8aQyp?X>_JPHAlS~FI@byv$kN=zlRJf z2v6`Ir`JMUnYPgjqDRG3P;3`%#Z}cDi^lISl|OCddNVDoG>W7nFgydu$LeH{xDT|r zQJhU#9DnQ0x9h+VhJcI%B#p2|wkZ7*C`k^8? z`cYd7k4||#wS>~+6!o2Hs38qetD1IDcE+O~`mHhzCC(|%DKj#Z7ttzrMcin!wNRT7 z@ozr8v}!WO<7th#O7jip%{1pDW7`|4lh2Ks8(Qz#;3Npghkqh&MJyR1YEBjs2 zgO)2w@awMoi~Gs3mne8-!-PB8Xwu)zpYu`dVx&Ett7gL8w2tD{jR<|{7?mP{W2laZ zMTuO#u)w@)Q{9I(%Jw@BPYKxR>|xTIE4Vh&I1@IZw-H5noWOF%y)E_A2ea3UGBF`< zNaw<5OZrYFxrm$_6u>xuUEYu(B2^)k(})7zcy5O88GR~dtI`+A!h?n6M!-DvQyl9Q z7|AmG!Wa7wZPnClOcB;>cA0%IB29z$iL;UsuT z#qe8zY803z)!A!snJSX_)xA3RQDlO8yYbIhpJ3_4I;Y{ypGN&%p`UqsvLs`d+n5_@ z*$qr|FrkM(`sy2f`dmYKMUy>5VGJ{hM!EDig`b&WiE=ucBfR$>WCG)M!2XOZBukF| z0!X}8#{2s%5eA!VBB&NUSgGsN6cIrW$ zLB}0X3%mIczWF|Rh;~nmLWzHxPfspMEio#Z&gPF_@4bP`Akth6`ioh8`y<-}+8d%j zjap?UmR~%i50U?7ao($DG2{=I>}H~W2u~4ZyQnr-**kw!O|0a`9{u*wCG+P-jDN;R zKQ7)h`|7$e4B;y&m=E1u z?s4y(X*5l%En6<0!uldMvYFCN^6ZJ_Hdkd`B&X6OgIwiMG1u$$E)Z$-b1~Za2mP2` z!tN^WDa&*wi5WIL_F=#C0Se7GYbe<|s9J06iV^@0d+S(?SKdTg$-F3ryQ?Ha(ZH$}jKXvnJ=7dWUAvlox#hvpG5h}jWW<8rtd*8cCn zV{bZ@!K~Y9bI78N^@eoFf-WLXJpLE0*&rx%$siQq|7*`1o>L)=vBiGj`J|47>Z#0t zxD6})AEzI9;SzW6U*QBrcbL57(Xcmvp<^@Cw_O|^&X#X*6D=-9v_OSCNJJ|O0`^FzgO@mLMLB5(lJ_v+BU91 zHttLMK$IIdYq3ppJcC3lWegl~o|Z=KTTOt1LU3nH%1>xBP{HG~oUW;!hL$O+y5g*J zC;U{1FNl5|IgnXp%M(oInZafqaD)_~AVG!Ms-r7sDV4*FXb= z4cJCX_RJEVu&GZo?)yMl=(1RH5q7e&Y0o!-`TXXei3Ph3IoStwoRzmF`-G#7EqhXY z3|CcUZ1gl(4VDv`D<(6mimD*iGfy0-4dz6rB+f7$-jk$%@9Q248>X3PK2cV)Y9x(7{=&3QVQf>HUgZnSJBG33=9>HYV zLdry^YW^#Sj*3nd{}(X?yQ+$q|JO7^u2twamk00kM$C2M$Cynv#(5Yn8jK3INBXQ9 z68}y!%_pQn>cgORa+J!qXa zizu~nv(g$E5Fs>NIyfA6F)oc<_y-0f*Y&TcZVC07Qwdc{S(IfBQVmDuw_E22=v|Vy zHttouoEz^kITw3N6CpwulMzQMX{sfF+xx%!VjUM<2g$^rrppnBu*S6lB|ZS6#Tf4 z*9lAJQPXNHl0d{PcWfea&EPPZ4uVa@+`1o*Clq-^tfIiA5U>~gZdCiC3i`TQfeXnK zf3YivoIiJnj!MDld0yM=o#r~XSPM_Ya-EE;sD;`0JJP@zhe~CKGg(DF*sTL8;zn8g zEYn?;wSCgn+XZ~uBJaLspY~iR@XSJWOVp>j9j{r@Lo{ki_po`z7wWk_dTFeIwML>FyY)J5B*c=^`7HZNT&fa!$w4h4kbOys8fwS z=~PM?Nrjs7=cwnx>28Z2TZs;pHln|bkw9->Lbl49?-=jZ>q3<<_NP!(*EimXtSuK$ zUa#)nUEbElzi4t=O0Iq9A6R@>Yw*@*V#keQW!LU-!+74?dfm&{hAM7g@TR}c{+$#j zrj>SeVY<=~+H8ao`hswLM*xA&)88mmiRKEKO9e1AULy4Uj^3Fu_T!Ci%a z-qS%{Tx1obWZJ5x8RmG}+iHtwO0JY+azUswH?W~kvx6D3UoEyh)6Jz4s610>=)Rwk zj5=)Ol5F?xUlmZ;YGgllo(EL%@pBe1%a2!)C$cG8If1Cr1f41$Q)P~aD+HJ=J<^jX zj_GYyCD2`EhAc+=tZ9WP8uUNO#%mn%$2nFp1|OS{u=1#6RJ~fBcE$V>bmth<1?7W)aeF7O8l8 zV!nvGx_jn0*=b7nELtdf!7wBwT7(EB@&E+dJX$1rqyiNf>^`J0BVkBo^a*hAdb=L= z>TjpiK_Ztptq}JhK_cbdF;SABJw<#?2qY^ zl}(R#erM~bFjCHu2QNQ(pM-j!FwcciGmH&}IyU(o%m{}v1opqwf&HcVX%A*xnk@gi z3))mOLUn}@5U)YcV(27H0s%qcJM8LHE2a3|mBj~BQ`OiJ{WNQcM9k%`F$A8(lOEpl z#m&T;M)?~BzVgZ`dI6L#{FE<5H3pu~cCq$;UG`$j6@RQ+GlfHa44HTcc+!+#OPkg8 zrYOEd(PDAX+_ce>Bk-~MBz)dO_k;K_hrsO}g$uTSH(iPadOU^};=m%57g`rDP)@qC zOY6FC?(kRe8N!5Qoykru8^MzKMcH7${;nzB24P=-&Q|Gx1wo*&KnJ81aswxlnz13kUI9u~cN1wpwCNF!2E@ya=al7N=S z)ye9fA~RaEfw}cXHCBg2KgesLG8rB<6s>%BVKpWB%K#h9A46%eD^Imy*RS(DC?P$k z{jSWC5bP!u4GlARmnG~0FM&8jqY=w9inqd)`q9LdgtrN`__p=^HI zCKmcPrX1hGsg*e;%}FJ6o^l&XsbxTqV|dBd?nzY|1I%Qo{|hXPc`cX zkj`S78Zyl!iYQS^X?2j=Q?jeA>l~Ej&Q~pC`0&gKU5ZO3U!r>AXKw}svYZ$!WgRi}uV#o)IZqSnwszANQ7+wQI^V<_F1DrMaK*3(SosF`g}=|pf0+q{ zPLTtco(Zs@NG0MMx23Ay{dHW<8F{9R4Rq$YNI2t8K(iYx{W5_2E;$UHY>)?V;tcs= zpI>jHy(qA_eU0NVUEo1&z}0p@5kZ-NO!rs9n&%13zPnqGt6NQi90t}E)!IoVW}ai7 zz@sT-lR#?VxK{?PSE5cKw+q>Xkwr@eB(eEwu01YA$1C?(R?gNA(m~?sTK#lgQz#O|T|T~ya`So- z0srxh9irPgcX%@IiCjO#So>TV4ySLYT=Xo%v*&rjJSaNBjI%>Aqw_Tn{Z~cgrVgh8 z=(R9FSpP?`8in#!b8lc}JmRs7L#OEz^d*JBqy)Tj^*RbEje(emACv$iF~}&d2yW%6 zR)N~GSC^6BHlJ9V3OrcJKs$IZg1B(RdavjI@$aXj!AAlUoe|5=`}-}|n&*Z3>eK;i zaouLq$ir!gqIak^l3B9FZ*nBU7;eB(l9pUuMh6*vBIdd6aeT6$o^GeY~h zD#Kg8N6*#A;xeOd^lCpOJyCr@oNY(3xB@cBe^AE_7fO%%x@SLNydM`O`#Md2w{g?L z*1gSaeZcNRL3nImR*-6{wUu0f`XI(3Fa7U)lOGS&P|YPLk{+A8oC0s0$bQZRgTy5T z9|=(~PI1m3d5#?Td*8p$yZiN&=!TV&?tECn;NASavU7O1U3Q z-Ontu3NQVsNjyYwYg`52vVH|EyLmFbUHZ~%BbWTRKY-hdet2@D&q>Wqd{ z={GYHj7Wzfd;xJ>=RZ4)%j%|sB{o*{g3Z*LO%Z<*u4lnLisc|W>xdaO={xXdCv2Uv zc={x8CEa45b9dFu9h4dp-0Gd^W!s)QKnvl@4lygjr}e2fb|tyc`-qFw_tS6&^+|u$ zwwSm(dM0d8I2P2ozD|@R&(J(5wUv@MDZ>-H%nJYaEA+1m*%A{P$En~|IK|f1XI6J7 zN;-8l z;0bseUud1zMtjRPPEPr4;3WlEv5rw0%pc#;x_cJJY^x;^$C^^$kY2Q;x2C5e9&dJh zT{3ecjk9%FX8sy?a`@Q-v-iy;Zf4hE|1QzH-L9VD&_$!bLJkDp6<**U*Ka}e3Yhat z{3s?6Ks->7o^faOI}miMqJK`)1v9oRkQ5VN_d|`3^|99SNX0vwj!?r%QE8- zIAT`aW0f2~VXR}#f|??DOz0CpB}*^dJDzdJND_ox3#8mQHj>gXF^5H;~CevL4@eQ@={f+ASVGy`*&3;P~yb9o6`{hKZx{<=-;-Y^-co zKzmEqWCBS}l$^3_3m*MZR|Gj2ioeXjn)T@yvjXuWc80MJwHU}$Ft%2b^RPp*X!&!p z*+wLN4>@3BKUHYQ$~BURv$yPy29I0Vi??|)Uh|wMh8j{ztBU?7T`>FdvmKc(!F#=9 z1Wu(XALKeC!SyW^(uIO@#f+K(^Yi2TCA6o7>OI!y!Anw3Vc(sa{rbmdti3~P>y+iOtAJodRYEc5?!mj3TlZCm%w z(8FUS=D%CJAGy2c4mUHxvygcAt|EB^vtS_3pWaHjuPFx=TcsGWMj2y76m4C_P9-tK z@2Z*TF4k*3hXOA*dmL#a9KL_HM+td~k!kx|7@J<&Jo*2`KhcGw(9hxffNb+89+qs} zNsE&><0oRCULE+xEnd5^-JSK?GFOny&OE2?KXQuQ`U1=vkiy_XNRl$GAXjJ0Ad7+Kgix4D%kdq(DlSmQvJB2)n#tW55fVp$n;~rc{ zy|&1<$G;GP_QPMBfO;?Otbv^))|s3N32!RP@NIfx#M(C-HA>^N&9eBhRl~em<@N1E zyu4Z5$UHeDF%4yk$)0H=@o!zaHA@}iL>))q7D})Z$Ct-`zGwqWyD`84A!vwr=)=0d zlR1G}Do2D@L57hjJYW*@rhgq(g9V>aY$`@_0!YI-{wRa2S)u3J_hLR#zz?d@H6(^P z>*8b$B1z?#yV!;ek)-k;M%1?JusBL;thBX4q_=tAGG(f;vq^XS7|pCEp+%)5J)smp zD@1(dY8~J-3fQ|w&PgS9bhld06K@QJSM5w~kQ}!rNJihkL^NX*T)ULDnX`(xb;mhB zQm!V2rVP^(=y9;?E1Sm1Ho{<={?5p<%Ry1W-B-b`_XXBCJ^r4_^8@0Fm-C08$Tz3Z ziS5Q+%H@Zi&RDy3zCyOAuakKVGDH3yO^r&m(>&KwxJ!u4_5V9~cmS0j&gxTt;3{6t z-A2ya6G}$b6c*0_jazXzG&jmj@MOthhE*74zHtyYC>v(!E#5JQThsFBzHn7q6deRY znu=%+3$^iTkcmrtTIq-5oI9?GHtCO?f2yZH z?5>>P&<-)NLO#4&Y?nL3^JX>dv5Onc@dD?+lcu^Ab?T@XRDzD1nS{o( z@O_(;h!t}8>J#x8;`ylO*reU9?@87^R;tuyyM_pep~1i>B+qi+zj_^yh40ME+PF+u zArtC`F`e2m4<~C*g9m@|81IimDihB>OiIXdmTY%TM1X>&0-p&r zZUSLeuE_6P^5kiTo59>`Af(gmUr3-=ex?gaK=}rBcXmfnEi3NuCZ{Imuxt)VRxeI{ z+V3&VEyri^BFGyu$(YDn9FHQyl1t#y`a)vOvh+F}Zn4FaM>U%dBii1Vs)aH*4>rbG zIORI5$YjJ74V}2bZ@V1(&8jG1{rRL`(0OVv32L4SOv6%SGx9C z4BNI@Onl^NjYV%K8xAW=0+aXz+hr`arEq9sP# zP&E3B60I;fg7B*e4!dcXR%3k_vwPYi`ak3Nl=JTM(557%b~WrXyx`uOL%5}mm^v-w zA8wf@5bGds*VLXMTIsSuWVUI?#j212G!#5rs5Ezpb|Qo7$AVzscY)ZS0{8pAO;lf= zoy2s-^!)?2P$J3j#2XRhu~^l!pKC40Kp&yf!PvuE23pj6QAO42{?7o=ezGCz}v% zFLI3WoXhyGgo%~apMwk=OJxUl0+M_Zoi|gmGHFs=>Pxf?ectfs;>XBwGA#q{;?SH@ z>ChlLy%WP?fCWRjbh*oYSAm*}SYLm)ILKYKqF&dt=bT@BMo^{3?M{6@lq~T*QYdkr zS_@hhGP>M}qN?=f-LBX-8Qa?=A>b#i#!w;wm*=?^O3LM8%T!($V7EwMF5g?xRSvFC zrOjf|lv8`~$`+x1RZxwvoVPiQ*>ricGE303)xp3`#xS2{!}q>)||8K6qS z^9=d?XWzRq=R15Yhqm^tzvAWAn~BmUbn;KAakRjjEAeIlB_LK(X}-5^w6`oR2<6ja zSPrKI6iBK?-ai%ctZO@e@-QlJl%;_}Wilil*IXDKK!SSeKStvZxb6HSb^+$i__laoMjWwp{4k!_W%#*vwd5 z;p7~QuV_k~CIlAT{C~V3$}_D)tit9o(I^TKMA`7jZ#n)&^h|CqD9JHTFuvyfw&zu! zY7lJV8^~`W+rg{S&RHJA+l4x8o;>w%IXj!G_=87ej2`uk4%5OBs;^EBz82GRA+-Q)=_GIk(zDRE_Q}9vzNHI>cN7aj;1k;>vfq)&Udsl~Z}77XK_zWWLNgiy~q&l!F4iz%JMJuqoCINLY63XdV`L3r&0hRObR?r?(GI zo<3Q!asO_{&PeOpDZt-pL{wRH#P##ssdY#;pH(j??g=VS$z=(492vt@CrttOUIFgJ=L_NZB2bzT>-?BeU2{TWmQ^_IvM~nk+R)2N!#1 zmb%Yz`>!pagO;3Zobh|8GO?Ic2a!Q;5u@j67CGkfEYR26G{N7VzitxTUwknAZ|7*m z^RUB>u|tCBb8n`$Qx72`BpGp6$zm&IdBU0d^P6mJ)^DPUX>@1 zwX83>t+v9pMYw%i ztg7~)E780T6gZ6>mQ8(&F23p!|r&?oBB<0iezMR9TC;i{!XrJvm0nEt9Rx%s?> zS=B)BGv#H(OR!_mX-jWcGUWlP;fpG#OPeDU6B5kQ(wJxW1{djy{0$O`Byi@uT)<~! zyJu4`^JN341#M|c+4X-0t^6H-pulNfAnNBlN)edRw}Uy+0}ps(dS-EGK_A`{bz8Lx zA?FI%7MDvAv{mW6TuBDVt1g%s9N99f%SVM2r;MB^fDiOKS(mFI`G1ZVWQi5Di7AC` zoVqCTalZ8pe0DU|AYq%25ztk6u@dAoFLJrK^l%{DL1MO`aRr%&O{8R|v4S0bEI6u1 zAeJ>Q@@>O8@L4>ccE78G1d(FUX@Yk~MZZtxoQ{qqcL8fIpi(bOI7@vEKgTZ^t@F2< z?_9yTsmat)Avh_34F1*bC7Lf}-;o*+ZaZ!%dBw-c$w%3S^PUKy1?+G3HqXbJ)mTfG zkrbAEV{sONyoq0PSD{l2H=QdPD>d$=1v#~r#3DuTf`*i$BpivvMK0Kz$Rg)M)ltB5 zA)H^I4O9CTYf^Zq#+W;UoRfs|*+dd{7#e9xyHx^WmIX=WXbCft(d@NN+K*pj46Ey* zrVjdr@FQsGU?{$abcDWDICwwQQ2wpDsi9r)U>h6EGv2UF2Ro7VI5|R^ zjujuf%P4|?CtrvX6TH7`%c+8QNtn`^JF4G$bWtUxg_uAC8zn4;MD;LjI37cIEDwiJ z*gcJ5bYicIDxl=ESa|7=6(DMy#xqSOE^|7eA*PRHs(pjvDuwl>b@`^lT&@BJCCE#N z4&rH^8?hL=u*Q}Z;zNaLdcgiOT&%sg;&N(wy-ye{qKf!+biauX-BN>08>LV=$?Ksc zaHgA`b&gBO^Vx!rt6RmPyo8w|1+GS8a^})H`6sT|%FfNCea|S8DH(OvU`WCP-*obB z5|0-KHg8*@H^KNHKXHGGZ&4*<%b1;vdfcu=Goo|+tNqm8}a0+*LDIUgG zYJw?to5>~O6n)THC3vdP&*}kXghLyy5Fv_^7Bba>+3Przz0!7Q9vqe%F<%&QJzw5p^Px$^e?T;Z&k|>=;!6dIZ)6UhQ!E+?oDY3r|au;d%%DDAHCcq-{91=3>`Ly^C zX@7yU2)i-lgH!1-mTA`}yZUh(EqdutQ#u~0&n!R~HY(opWHdWOo9f)R`2r3W?ssf) z-?b;2hRNa=Tm;NgrGx_IEHgavL3r^ERBo|Oh?MeE|-u@kY-T@I056j^0#(I7h{i%UBCcJTlL{mVw8 zVOztcvn&kyw-lFeLIsQYoN}ibRD)+;ScQqc&~2z%e1c7$)s7osHX(kjO;OJx*L_66=ne*J`%8ie?jJAJqw22Kz>A!D% zBh-RP7S|9F3mHQEd(mPap)=Q`)ggD%#ePlbnjwUUV)lj`gpo0*gsq3$&45d34qcA#DfDBadH^Gfl%NMg-SXp7)c>9 zPuvr6u8K^SvsC2WPDOHKD2gh4IKOB<{427bE>pn7ct(I<_^h|KdA^cK7#OJHFmU3Y zJ9}5^yCpr3zJK_WH!QUK)P_M{Dt4q-d+~}RCQZ5QS6iPq5f^4Eb!}cYlE_gclsF`| zEJt_hbXVyrpOLxjpZ97bYnDs>_}G3_WlgcthKznh7P2Ka*;CFL-Mz^e`SPk097olW zgs>C1e+55;27A38Dx4B>An1!gc`?8>dKK}}#isJTx4m63=aya-KV<$*(AdQy+W;zx zuaL^j0JKleemjmlJKM^RE>%2EOC&Zv?-O=nG=v36T|L2JcP za{^mhE+Omh4I^2dWUDQhu^DWljXmHMDH4L5ImW|}E|)upV=}<1$t}fV`pccRnhYnu zRkBW#u@Cd#R#aYR2lp-DB|B0B!l1}M!^^H=;6bwAk<|N3@|}+aCwg9ycmRgY`5iCp zWJXsoqxo;FS4k_gmpLKx(Dq?Jjt)ElUqy`4bsOTFPTT9vLL z^~iRms+iuQ#3Y80hiB*KG|x^O1@5@_im|alE#|Cp8Atsc8YzXq(*fk$u4(Kqe*Kfse)k?*L&Vzh6!b|B z&y(I>r!MVOeVEiP!uY_;6M#XIm+QWY!OiEdv&i+cE8?TLucj~x@g5zm|B-&(0==aPIYC&Ip{{}+7O^3I+ir}BZB1<3 zJb9k?yytwGHEZopd##zhultYR)t$WHDWe`4Bd1ST%Z$Tz*(U^k(d#@tu-`+uc4!A( zcnoFf;g}gl9B6<&oGt-ku(sSNQjGS#KC_peuZG*RLlPU^3u-StH__>P0pP?0isxlx zjPL@W7KK!*ReIg}>-9o(DTB&{u3?BXs1f!m<_@D$Pc{Lv@w>LQt@w&%X}0X=?9e?F z|Fb@jOjzMl3rKMpyX}!!!e&3VT-VPI9@c$ze4F~h#bhQtQ#_7G)+(dB@sGHNkjJd4VA-Tg zY^H?5Ff>BH6uQyrmbSXlNte^SI*0YXF4Aa~y$^pWf7cu_)~W)6xW1K+H)b>OyZw`P z+#Mo=8AL>hw#O2eOux4smRcGCs0A*FYcxf=a8-Ug+%Tj{UR&5(NZU+2O)X%SW=o@; z>34H-hn=95Hq>*A`6RZ`eM9l|dK?jqZZoR**{%xdsc;toYZ6_P8(WQbRe-I`Go6kr zkRW%Vt`lj3G}F@1eD3EYyK}ctbeulSmng(^qW1h1IJnj<)hPsZu*+BTtYoFrowv6B zJRJCN1#Sv3=`vd~$;L!fBSRF&;Ms`*ABx z?*YBDF?Y!M9zd)NeUMy#w=p2StQVF-uTcU^YmZG)4l3(t)oJe0kfY9 zA{Lb-Eg)ibICu!?sbS^Pb~Mx8)>f7fBv5vJrM zPp_#H-y|+99oU>las{r?-r#w;-hd7ewyhQt%iPC0gP}=4p{s3>wBKdY6da>{9WtN) z^L2#QF0pYn7#L!jpPO&0DB$-@YksuLLQ zumj2FBIUxhCBdiTuoK$M7`xDTgG_pVIphD!KU`w(HRYtOW8uNpgVnAMw~ z$1Z(5$~vsbUiC}k5V}sJ+8}k+Q!KmYZ>y#mF3#!z?XQ?Zni=F8QAv193wwX1304|< z)M$@hiBILb7fgzgz%-ZAd70h7KoOqMc)-(9WHs-1pNwqVAkRgdVjr1?^y`_Cg#O(9 zii!FQU4m;ZXcvw^jl()*-$n0t5&Udzd)_mkSaZ1*w=TsP(BDA;sYD_8x>o743me99 zlCs5xP3RBBJhtpA6$Fz?1&rS@4lsN=`iNdSjt$r1kuHEY{@?~1Zq~sz zQcPGA6f5A1(ZqpF&MQA5+tKd@v_H8=rAw1o2*fpJNq?o+p1X^nZk4?hcsCC&%3@_? zgx!S1l@II}!xZL@6Pw)WK3|UV2T{TtjZ$LFWsQ2&BkKrAWbL~3U0}5PJ+vO&#UC)n z3LWK_@$;>$TyA*@jF%9^X-=~b|Hh&FjWY=vLvpXaAm;ERGCJdMou+=7kRVYJ-Iq)g z^$4f#>)R0U4cB&ZL*VK@uOeWn<}5L)h}I(ZHF7iECD6|pbEpHx;e5MztkdeLs^}DF zCY7M$@95K5d9rBE`>j<%OoO_V!{pFAcOl#$@X)7Ol^V1c_yr|a>AaGDz*ZT6jepHBi4 z_n!jlyn}Aog((9iZ&0S=2w8hC7F#S6B}MK979Qg*auh=rst3~(;LaiYrpW4&P=;@C z`tuOTovOb3l>G~~K&%O|wHRL-bMRzZ31DD=j=GPCn`Z9+{&W!go+3yVm>zFvCx;M( zg%|EXA@gquI3^j(kkC82Bk)b`uL_2$F8*PbsOXUFBsZonOT0hm#2x+?Ke zzQ(-GPs2cgfcBPO-^N@09eMs9ilx}}FWx;+MrT3eu7k*6gw)cR>|pB}kiC1g?wxxf z;dBT`-V=9Bb9z=w(=#a##BHsoh3#tQBh_GeS|bt#|Yo8fSdI0ZtZkiNIw|EROgAnb_nmc z|G7!!o&@HuE-B=A{#q#S#s#w{l6w2|%O1i%R&_1FcCPcJ1?YzDwoG~FE4gtIu@89<%-~`0e5cg)6BOaz)cLx(%yOsY%4x z4gIJ-UJ&zI6Mu8H_%QasK+lm{IYHH6Wj)fqYSv<&n)$5sCKjv;g-2*SENBMU2TBGBMfT5jOhqFT*DrUkq_8CUbbMz7c!uf(SCmry;}YEO7Hd-&`i7B} zlP*ud+%DwD{#E?eXcR=A@d+=T5qe2*r;KYl~f(kZ{%K7DSEmV(5h zRhZvB%1cToZb4QYtm2jgK`GOCfbwlmSy?JH zq?Jk}4gdZ&d>w5@eLfu&dyD6y(_1YiBhJ-HdXdXb);@;kg6Ixm^-U?Ct05zIAAIp= z9kGfx^r~(@aZorqJ&4-6DeU*V58K3H{8~k-!vwKWIweUb$+V=t*OC5(f7cXNa4D%< z=z@WkwK+{0uVxFDF!-Ca$H@v@cn9J?Fahk`IE`x zX$K+qRsCU??D+R$mCH(9F`62IA=Rh>UDz}A9%ap=E@Ek2g&8o;Gq@UWbhYyF>uZs% zB05@^If67~=4?Dg_boGA;iX$Q3%w+lD;sYX&HHhF!NV` zaplq=)NPpX_WbyrGAY5ycYqm{KohYqn%dd;;5>Umh1;_{CDrpvCxO5xhUyzPYC)eWHsJZ(~DYTWXG@PnGF{uTQa0CWM-!t*E^7l5BnuIh= z;Zlr-ZpDi3-}GTN=lm^aS^YQhJ)XV@N*wEI16$u!({#hCP`WTl{ zHKs?eyQAi5OHa$qKkA_?!Yy%FQGwfvP!f`u5+MXhl#F^k)V{?`s4mU(#>!EDE z^sxe89HiGG9&_H&OOd0a~B&?5Skrx(>C>J`WfgPfeTkWFTEIC7CFy zQ1JYuz?iV3uASmGRg*dan~zsEdKaZd_`M8$KUmWqu=&8O=~%6~%QNr2pvN_M>%1mJ z`O9W^bEewu_*|~!o-0feeGDTwXq9B!&qW~6WT+kO#^}wNN63am4Fj_!87@{(V>>3m zAueao{tZ;TU;N^_VI1*YaffN1I}Vu_p>wz*&`V}&wX!t*;mv1 z3B5S>ZC-VnO&`JZ;^b8Au?cpfVG5p zUUgrdE$Jef_6}~tqNP8hC=Va<#+0_8)E!O94$9Z*XMP7)(k#p=Mqz7Xy8+3Z9hb%B ztb3*edu-k7D|7mUdqy_I>-4&3nRn7aaoyH)@U^2tVOYcLf5R)eyPgoEgpC{v`HST+ z>*KH+spFxdLBk3+*DZ3gehVMf@#NFl1gPR7W#s)tOSFF(Kj>EC0MtR=)AcwapG`b5 zR?EB(0LYk`Ky|N*H}};Yn5{GLfX#kCK7eTTx zMcU~hF7m{V>YG+DEvWUlg*TgINKb0ZWQ{LkF-N`d(0E9$n%{+GG&Y$2PTS9&rFBO~ z*AIi(-htf#?mnjp8 zifGxGQoU70^fXMN2}__TKrMwyy;@Daxz9syNj>-o-K9`y)de~ z5M_k)U`c!P_7|GNYW8S?{_~%-U{bz>t-p`6uyn<$x@2)9pt zY!0W?cqwn6#;AVgp%9?YoMWHWzd+3LnZ7ySQ}3wHtHiQL<>JXwa))oDNYw+|3p(eS z+n4Y)lw!4IL97q!v+DET)Oy8IcTMDsO$b~uA@%({ozGYZd>h{FZ)DK%xr&3USo8EH zq>yywFKI2sGMnTy)F%b<{9pttNTh1yoqu=g@P^E=GQ{Tr4PReD%VCbnl}P~=j0Aa= zZ*~ht^88_Dvam8sQX+j+QC~5WF&t8RB%6*rcP97klE0ZG#RK#wgH&@-MU#+(>%M{T zt=<$%xd`>h<_2MZzg2Wp*L!7w4pJ6g3H?dXigy`qp9|VM(boOYy*GYWs8apfuZoy? zc*nO|5j*Ha(~QfoNnj_Zgz3Sc4**Rx)w?pFriaG&d7KPGPhM;^GC2;>;tEj(V&dWE z|CQ3av?HP0GV#1468n1xBt$Vs=Yf-+9j}f4J$)H=M}8cD#sm<@d8SGeh6(NUh!NV7 zGG{ACy@x$nw)Gd^`?a*sh9c%jA&X2;K{@|Gz0b594@Lih2BaCvW`?&a$_iV^ zqc{0>`3J6iiK|L!3M?DALB}AZS99()_jWP%Yx8+XgTs;0LDkCMpwrmRz3rJe3jOld z@iTNhhNzT&Q_aU=I3Kf}$G_ZT6LeEM*&(x_PD=XL3~PmOM4E#d&n|S0v%(|V`})pF zL$YVaAn-hq*8xtLA3N?DAH5^!8bq?(K#j)M4jfekf9TZ7t@^soj`U#8Q?iP)1pCh* zFokw~@wX_*Rlc!185DjHz7iE}=Nlh^8JEe3qA<8poBz}^-i`R@j^9uw%`XQguxfRv zctgqF-M56#$5(Y9@<(x1R2jc~@ycq`9EN5aya0=F5h;JN!HNRo(Nt&B(5XY-1Qy!0 zJRmmksWzl|1T#3PuYF$+!XkXT%0-+nKng1lYw&?!_=EXH|Bs4EKZSAo3a2a8+>u0vgGNk9=C| zVMZ7)2|0#%4hAG0Tm_Dpc-)C2H#IBMOOI1e&+_+{S`A zCn2gvQ4(9M0ZF#$f9eFSro!S>HsbxK-yzB=B1UVDd6lU`uKuDV*^H8SdqOv1XN11u zet#6I?PU%S7EMlMPJXo=(c}NGZ&*S&?+p)vmz`d@o%>m$anoLB({z?sbH2YI{cc>( ztRi%cA{+r=A}_H1`YIIJ)|x3Nbs0u;3m>?CIY-B%lJXJnr%v#YgjC1}DMh1~O7{)B z;YWUp;LWq?GtHigt!Bp&Djk*2ztP_hwRn^C1_sM&6FabOGK)&d`7Q^!h08f2IL?*( zlsP7eZ9I=r!sF^jo->WhdbM@(bs5JF9WUSIXCL`RvRl<*s&1d13Uk^Qi2usEwu?8; zd`XIJ4tVxiaH%^_PT}(?+~a}Rl)IFqvMJ1-(7}9?35$Sy&J{5(Ny6K>rhRV3DE9@f z-(pw)So@Mx?dKhR*yxS4mR&-ep=))6eu&B7kT&Q?-FHv4*|GBc(>~!J*I2A!#s%5H z^%ijN$bg^=ba$jO;DHo-vk%OlA!6Kn*LO_Z<4u|~LaU-K(Tm1A5+s+q*{cM;c!dpk zSyla6$EuKj<2ZI&zytpiZJW%{9=VgZ(lI1%p5EWQ*lcLu?W?Prw7gY=^%PJmsyNIX(ynhtg&sGtWuaf# z+r$`uqpgSO8E&VS#6n6BM{4{}DT&oO^_HJ2mZz8i4!sbVL4hAwh)-Y!TndxAFBgkm zGFAfV*GErIWOqDbD}*rDGMl6jgD@2L#iA&geRCatZiO`1MHnGw1sYeQp@Pt5Agw$Va!Y1_S$=)Rub>KNDJco*OMX!h{; zxr>dcMrK;F&(%cxnLbp2e(r9z!}MIDh}$DjTuQx&lN?@6Rv7=tceAht%w^`9EN8%L zRY`9^iXWvata<=Kmv8vb`I_aA6*pV03wa9%gT{SZ9wfhP!V(~4*yJa!g6a6}>v>ua zriJ~jt(H5@R}V^azs~a`#i2wizL!MNk8jf>Pl|Jpf7i#=1us13Zasa>+2W6AHoSI~ zxcl%lQ?>5TH!-X@8qV;J10{v9VD|%H+h@1Nllmq|(AC|wArCMGhhKIVP!9AdYp{e9 zr<}YJEytBlzuX7p+-UCAkHNrISJ@oJC-kOD`ybpAVTaNpj-5NpC-QyDxWhXqzGjdI zW5?ig+4mHnbVi@hhh)Z!qr zQI>9HWC~fHFVYUut#*VwQB9Lre0l9yInfpin7K|M9M7prlbiXT-37U2St)o0$G=pC z#svlFd*UY^`AYljsdfejDi30GJIc9u8AWEjWBgBEWJI%b@jqkf)15f6-RI+U(V(O2 ze-isV>M4Vt-%?~gKQ=B-a&BZlFXtL|Cpt2AQ6{RX*e5Hu)$OQsy%)Y#p(Z9T3N(7q zoIs0sEL${$v#P!@YAKZaX}%D@cUnZfc@<_s1DV<`#(+nFFUQT6dpgk#eau6pu29pk;rTvn|Hi3?~p~K z`p&G+=levM^S`1apw@eJw!~-FW&D3q;h(_Q&%e#{>wj-+YD+xun}U`WZ*jZ>ru1=q zROkTbKx3VpfrC!4Hx=q#jeO4isZ_HRqnB?0S99pAD!5o)32}4N83#vu+XTqK027GO zP}32VvGJZysL~+xcuC};)0vqE8=Qofd|-e7|J~e@O|P@NZB}8ey}k&u$?iPo?wY!J zLR&iwTueSU4_kC!xZ-W|6lFcKGyfMr;(T+F_`AP%l#1{t)&wR3Kork5~SO2hJ zeNtFW)e5&@RO;8HSA=*Pz9(St%{|bva{#VJ5;s(z0@PdgI`|7g+FIV~Naz{x`tO~< z4vkXD?`Q0^k34!`;|=T>X*bVM#h!XOw>AWQ+E@6>Wl?>!*p(|$;9N1xeRnwMAo z(@59ds=a)!H=C9knj|OZnjxpA1q>9 z-7`VY(JPza7jlaiS4B^=lO@j?^MA`t$LEph-|u5_b|RBtREz;g)RIs!SB-)!-UJb) zjW*pmBK-WJT2!rc&cA-(+i znm9&$=#Cibl1?ItBEH^g^3_QenzP=#zY3m=GP|q+j%*x#P-t*ixxri-TyW*)Z@#WAJava2y$NGwMsWVpin^9x@F*)sp{J{DFQ%74EV00K92i`5<4e361YrfBK7 zl$`MOO=*8pAGLXdZkU8Uz->KG2^TO2#X?)X)Iv{0K-&2qzz=j|+o!LI*{GjQf~Uot zLVcye&GxTpUOTz3w!cr#{I4@}hvzXz{19Pn2%-0U{-j;tCaiya$^D3iTWIpG8ok|p zlsqZ!yT+r-VW+a^YxjKzvwIVaAcsZY=28?#Vb*q)w#e$9|Z4N_o4|?YOo4U z6e$<=kpQ7b6WE`o4sDc78;H$z_(h?GZIwRFFM41{M!JR&l21tzK@)%(+=HpIYx;j< zP8K-o$S-zXLq1B;5>Id*#Wl@tSF0s|X#9~Nn} z?Yj5+k!xD7p5%TJa;)BOGhDoS4)W@Y{GxEI11_;db$%LO3tbbW@B*n>5ZdBjbqp$J zJId;93M!K>QfRo&6xJSQ5TseT#SQRe>T|&}9;yxdH+b4_g0{an2mgKvz59A2l8T9t zn1mM(DCoFJsoN3vj0{TlGeD6;4ZVDV7^!V4>w6%c(5$0iC=MJ_i2qT87lCy7vn;=i zded5#)b~-%y6#yZ%K$&V2Z3nNA=FeDuvCph1F0_5vmDCa^I@JD5{R8SLYu}BPj>3_ zhWUpoHaq*PyH5OnIz>+Ig%j93VNCt6J)di{!Kzs-;%;fKm4V~`Nr3Vn<$$7LxQ@?A zGX;O8`pVK3Ur9#B$7~&--ab_Zp_#zdOtTWgfQyywO!S^Hh}69a%N&M5QX}VayHM40 zlMJ}rg%q-Hn>t~O+{fn+oN|YMQCug|$@$XrE95P@=q}zdt!)Sn7&CsAs~yTU7oZXi zOA>()=|Pt_=w@uh>V-H~Hg=1Bm%AB**=M((gzdknBr6|)n5E43U*~7A@x@aoH{3cr zL5v?4e~{Z8Q;SE$B2PtE)5@Af)aFP&v4W?vHf!1A1Uo=NWe$Nq7%#z>ceq zIYBytpTYW??B{c18Rg;IMSe?eohFG^&yDN`O^_*+nL>aNbJQ0RInQ!>Wje5pQ)k=j zLl4D2t(5Z5)fRE?QMmSj-=xZB(#xH6*IQY>Xw;;hO;?&yBF4 zWZstF@V*5N-uEZWl9a_4*!~>JYz(l*Y${l1^9C!H zsbc`}4L&_`*Z_)6I)wZ`d0N$D(8onXuOQ>g<$F|%29_>Fh1)V6h!*RD9j*^bv0!6! zx%V}m^90PcfwcK^OZKR`gZcGxY$G1a4N#70`$4_WYrkOgTp8q?V@rUqLaPwH^D->; z!QILYzwLjGb*KYp>3HHo)SHXLI1MNLLYyxx)U{F93jRVkD`={I*Csn1n5b_W!FwJ$ z+caqg1|nTNfBIQ!umW##3mltmhK9rMyu@pSbER-V76cN^xcT;Q-+WBH20i`xEre zRkM4osc$wcQW<~!2A9^2=AVLh;sf}di}__0ITOOe zn=ngN3L7Awo4ExG1ELZaH?ES&#vM$SCCI8W@re0hQPEW{Bu?X@A)eSiYW&xt-pzf4 zvjzL#=DUq0P&OA}l5$Pd$rvI~>KE|wV=Ft*rrd6=qnBBQ1_fn2={t-vXjW;5_p(is za)Va7oq^-BiQeQTt#8Q|0u^PCjU>m9AjzR!D;d*IIOHq z2nk2pAdpPIVyetu)t_sZTS!wCR22vSA zn(;hdyR=FZv|6Ow5U%U@qk23w~<_gQD~tnJc&AlNrc`+2jb!cJrtP^EzYZ>Po=0* z0(U7U+jLi%OTs>zOo~4GH&KWZ1?&kDVfx&He@N3#xxD&HXK~XtAj)WzFGJ|mJ79H< z>YrE`o!QDu{Q|#gZ>dSLG`MbLDJ4Lfu_^VU<7_o@KETyMV=BG`$c`BWP*gJp#&rig zX5jkYn+Tx~|wbJz6{irp@ML$j^hEaQm$oq_*(a zkyvZMZAp-hx(hZ(=U?aXV6BV|??DzZTN5?+W0ffq{;pwhXi$fNFyUh_c(PHg@*o|)JuI;0;h3(94)od{VD0?wjZW6FFSPn zq3)*J+15>k=8C@0_X%;hAG^_tn&s?n&1x(}{Tg$pyT(k=6H{QKiDgV81{9VlAuO#0 z5ot<$s=YAkdKa4{TA2nKw480*(Vg2p>-AB}L+#<=7)WJNaBD=B7PHch+B6#%`M5ua z55Z>v2OPM=?A!4iH}M%R5Xe?JYP2`xlqo52sMPu}0}7Z`LNQ&f8*W*-+8-|Rs81{f z@e|R-G+w|BuQq~n2&yR%Zc=>0*mVFWU~FzpTS3=skTOKIh!O0CpQbrgan5IBijRK1 z$lSa*fdhB3Z@aZqzr5})F#WaK7O@J|2|B(TdbRstC?R7=7VN35R@4*{!B(={_!-)= zWmjH>Q1=;b0(qK?o52y4Pof&2rexk4(0k;1W=i1RzP4f6v$3_fdZ&CWopcVk<{rP} zfbeT5*kcnHkkV5eH_$ri&K{wc-1|ZIj!GM zaoY+Kr;#O#87@#HMDxKk- zOOH03|HKny99q}r5AKPinsFH?w5*kGW}0-Ss~=RK__^3tmamFzmLu*#UF$G?O)gs; zJdjKac=Gz(vif*b`F=m`JFge~U6Kq@0qyb@DTMKOSxp1?9RwvOuuV(8HcoC?eWKWY zLB>FQY?ip)KkD_Z^6!LpnGiDEv8g+}dkrIzUr3j}B)cvm`V}wKYFp#GwUNG3=G*=i ziOXZdG#MV0^ooV52Hd-}-E1Xbj^GKPQms5#+wrS@tWMIYqWU1FbpuGghz5SX>o$Uc z9MF)?U>h&pe>=5k<~}aEaS~*~YyYveCeMyWTHu}vUJvmH;F}Ko-183}+XzAxN#W>~ z#o{Dr5{vPLV364HLP`RAjh8IS`Rz~Ale}_|Z4~4Z@jh(*{_Ng;U#${iWZXzUxnCw; zw?(t-1k;85Gvg@DS+(F@=(b*GRdk6G#mqMr&XbBG+hTeC!7}p7YUy`L3KsBwoXQ#G zA^<6M{VRsK^dt5|Q)d^TNZfr`rrrLr)KV`?F$ z*)~aco0#zwKWHZa{I8dYLYpeO>epCy=F6AGjepJR^~RFGjnufCW3ViQEV ztkN}F+e)D1Y8E@lUn>zHgJ34yWiS}}`O>f7Xlj&y5$bABB8m{jIfe12htwDT5TJc? z>~6Y{%gZk&*t|;UEpt(jO2iKaNNJ*o4!d85?}L?2vSlG%N>eZdRG}Xq_Ayd8%G&MN zi5fbZ?U^xkRWw$s9*!vw|$dTXu@zYtqjd$5QtE~LtmhCbxya`bxzy@)?`t_A& zF_T9rd31gsaI{+(O2Iu>a3!Zp^0g|%5K4;|Cw!SOX%$%Rn7(W|i`5NvLn;@qOWHP$ z!-8G*0|Nk4vqVmh?1{O=b$h1YoI7ro5w^2G-V?g_UXb|WiG|FC^bu33cxZ24`DfS9 z_oQLA^{($P$7i(g(U#9k@808h5X+#L2AqK7*uKyZM7ZvPk%}N2R-#(emYaayIZ{f? z6P8eMgp7U!aWu?T(tp(6(-PLGFD!OBXk;wnAxt*S``SfSCI)U#Zcf5R?zM%*tyIrQ4Bt-@ z7)ZquXez}g3h`G<%*r|zjOA75p+^GG8@?#J^+mEy#4(~n2W^8)FKaU0rmgs*p>R|g zowLVB zuY35mX7DaR?XbpTlhRBb9HFkJ?=M!|_ zV6i@7;`KInooJ|5Fyy}xO*2z(!>b5T<JZ1LDm4bcZ0k>4&?4Pa~Al6%?mDKpA zH5@pgsc(<@GRRcXt!OU_S{Hw1Am+Eio`TqmLHec6Ow{4M__=G7(!s-rxP8OI=m911 zbuYDY_(NuPc|8eYttDf9@_WajeMfY;Z}dNFdo1g<+o~yYD4#=nA5c=-hYHWu{9e)t zVO8S5&*J4`n%<=4!Q!;><`kK-H3Pc8bN!>+Q=+Gmj73cX65 zCok_jC`!Hb%}tm3b~8qq_vhX!Y0-)Idkg!D;wO$=N8O`Sx72~{7u9>NYPQDg^>*x+ zy{wt&ybX?{yLR$D#LSq_erMQ;&xcv%=9#pL)F=`aai=L`h87;JV51>#Kb0OoS=`X@*PS~D9vdX{ zI5Dy0O@}BmC&%o6FST>+I2hSEsT|xKc)bVEhf%2q>m{du9dnI5|#zSp9T6dsd@r#%$4^u2d1Kt_PvO~HWV!u8%Q zGQRl*Ab0up=p6e_rEO({Njwh!{h#B0O9SYHYrOhv>1SWB?=$Pp5{S(NkH`Q2TDO?!gFBuFDcSC9glFC?Oo z2mfpPjQM+oPb3U`A~nagJw(^S=cPZ3SR+=UkwKY(8&Mi4T^{vRO6A7kKdBzdv%I>K=}1~^ob(qt7`or2B0vto4ao1|0z*gl zsCyZ(N+**Ojq*P4>CTN}c9M&m>;wiSyW%WtPPsd!cY5wB#l+Ed+{4oV224J_Gv9Sx zm4c2kmJthe%Gr($uiITC{RYQ*BT7WPVX}Xsj)7#Vo=z?kquN|WoXP@Tz>z{e-3xx> z-%LabM@(fIqNmUUhb2AcC8|g_6|MG3Xk zlxvQU4Otwv+r_6gx^z|V^o3$@p@K!T#8|NM5#unQ{uizSP0mg^@}*L$=u%;UFpNno zYHo-OPq;Sz_f|a0C@=}d(#9gW<+a{L>PWfgTt8PzY(h0JO9nWqOho;g;{S)_3k$&H zt&Eqg{;No=G5#g#CcY2tTLByw>?oNGkWD{wxh3*YgbnG@3IyF3_}0KBy&h?1O`f&b z4i)hsGyf4pz6DzA86n(A@>iP^#H2hKgke9db$;S6~7dO?QJW+Rium9)iCbK#nKXm#Pm;& zflZsQWj5*BqJhvw6d;xS0|D!c$ab0O{6cRd+AqD2m=w^F+x00BKW}3>XT+`crxp0X zjp0$xLE)lChDCfE5NVhf%wdkQi(Mo6KaxS{Y=^G>v@_0n> zgGszV-fOeiZL{3v6?#G=c)BNeawSOr{s~JWNbkfgT%E&5b^dn0;MWrJ)}67IiZddH zkXCyj$v6ypTFvUTb@TliCgc3i5!agkd+lP{)qap-JaIcW$Lv>Y;%$iW>g!J`Tn?xa zK0p>GL8^VxcmF0OO-On(zMM=NNGo#maZ2o#fi1>0>~eniM?57a@k|Ux@Oy^ypCY`b zF~UrzX-Nq&-X; zbGFSMjC|5`WcI{^?~5+^Ep66S$ScJX>eEnms}*o)=(hRj;u^+e{))$a-vx!0XPCEJ zn3N4*=2Qvib%6XgB1J*p25vqi*Ub-&eG5G!r_tY|@#)~Up=Gk)DJe3uL*4( z*t75ihqrGq!mz@qb3HQA3gLjH7Vk16RdBwa6sMv=jq^&mg)|iYag%7uL04aK?2lXa zV61aywBqLIMPxo-;ygy%;z=4~-a)9zwq`xvkCw`E%ucKgevUsy^5K>I{NrP8F3G>1 z#S%D4rkV%*s8PkCCh_29fvi1>FtW;ZcGiOuM|NkR!qR4R=gu4lGov*8>iNgj#3=%fPFyVH{;}>$f}6B zrb9D1Z?}|s3oV~Jse?b`Xy&4{{s8>sBvJe!v|>6gult^L%`u;0DS{s5uPb);BpjY^ zV@5VmvnIAnbY>a1PJ$Kw27oWuBg;hO^RXvnH#^nLULPxkGz-S$rLshBw{S`^66b$2 z*=S?uV06P~8G@!!S@l+~HfvG8e@&Y#393UU@MP#>GJPxe8lNq8K5Kk6N8k^#Uf$`( zAMg`|;|t)w7{Y324A`O%t7Ul#K+j@?;txZW&bv?74)=fD7o4-$p@jS}UU=PWW@c`;{oNW|dGTVO#N!&V##yrTVSDzVaXIv*CxP%1>ZZk9C0} z;*YOjK!4~#e*pcCC}{bo9>-Hz@(BDcpfOas*Vi9=nk#*%Kjeu1<&UsBIV>6)C4Bof@+ski+{I!qX_F+Kqis{+w5wXRcOoo?CsR5T| z&q6t)JI(=~p7Rn9(F@z#!7lv=y|^L5!X5_tsoQ$@)WLWk3A+TGZR8P8=xB zx%4@$ti-+hllNl~QhmWkj^X-n$q;-jTY``U!KaB%wdY&8!l%q0K$C(98|?tBT=L8@kvc0`fc;bZ(AEN65Zdx1@HYf{zX_qh!Sw-YbfOrJReizXfd z2Yz#(i#gXl^y^qQI!SiDxyE0r3487VBNVY4_L!rgsfd7EoV+Whzkb|G3{Lu;t~|w7 zo>{Iu!*#Lua=MD{Yq^X_x1jo=SLGApjRbi1_GRp7t}h=p2$Q4qp;C=a>+dre&4Q9; z@L#;;sYFVD6gX~uM6SgAvgomJfMkRp=VIa@Y<(a(N-bDh-1~M6O9&Xo#kzj@G^!oF zjU0u%dZ_u*D6-p6j+Vn`Wz1et`R5AfJ=$qLmr63yM2ir;%dBq6n2t_&Kr<~O_z6lP zp^PIW_Cdr+uDe_qpOiiAH7Z;FP-<|gWVL&;8S4MKpD)FqH7FSfFpue%LRzdvpL~WA z*ZCq>Kvt$Otvc;(=DnvfPh3eZM&>rG`KiiMeU)i}a%$_LtoHt8k#O zm+EWd8~vAWU^Oj;)4mPabt!#6&ZSzC^c^D^%Zw@`Pl}8ND?h*QO9AYqwyDW}t)RC$ z=*j{QT9nMF4#A!{J2_DDj-$hd^WE^m-dP#vmQ^1Ix7e5@0cX3!V7lmG{Wt+>cGO13 zgL7rz(N7Vq{8bvYpPrhv<28oIr1RiyV?1r03)hnZ$E+!vW6xMAPBK)DImBzLO$=0-LUVbj>R{Oxg=Ivc0zZ7$GJq5hTy0&SCq zd~qjG#`!t5LDKq1%#K6w?E75P&0I|t6@&;~)UIHx27xO>9AV*QQO-#0Sd)yzI5MxL z`Xo6c{V%?g%YCH$)iu~`C&1x}$qO(4=7nsR0Q=2)Iii%}2-1}7l4%u}*%ETBn&>+E z?~EVy1uz;h3s1j(C&vIw&XI3?z)Ls9DdhbOIAYj%qnCgIeH1AW-7eSx(phkmC-KL@ zrxWc7zcG(bU}}y-Q0(rc)9sheBnc=2whMP2jApphUNzONRd1zfrfVQ&wbP ztHZ>RvjnI}h5@#jL)$z#F>9Y((+No|lXyC`qI2E8pbdQ6D< z?>l)?s-L{vs*9uHVOWxlzmTz1%r6gaKkG_J8@#p_n$(!^;`#T5l(Rgp%ZtqAGJ7SF zcDSL6rEq7ncVtvn-k2Td9?}S71UUb!#Ev zAyG8T(`bXoA4Yi9&ElX>{2uxn`}wob8RvojJDI~4&W=5FHTux6Ox?N;V@YmcFSh|5n$J-F8&# zFVH98XX-8W{;ETho(dMYO5MS!*m#iSrSoXxURM^&;aiGK^X?3xo)58Ti`cJoHL3NoS zT|zX&JdLjF9+7o>575j)jY+|O$|Js zv@5Wlw*C>Y@VQC_{%`nv;QwAKGOhS`z*1Y&FW}Ym^8bSC|NO5&x=~$DOH|`@%e#Sw zb$WxyOP`t==>5m4an1s5hkPAOBK0x{3bLsep;y%g^i}hkZO;Jc&^W3N?r#u%xk+u; z1$A4URG*Jm_lI@}ecK^W;4F2ZX|;SDy5RV?&I4?QZR@0_Jpu)~$_Ey<{Y+p49J^A3 z=En+|eQEb!84GUBc`oho$Y`MwFKS1hTNEhgW2-T$|H~zf%u9C+P7Ych+Vg#0Yta8% zzKp5?G~nexc~|Qg!#+>y6G+|Kv2tH%wD+5e)|W%lOYOVgAPJ9F?(!I=ooET&59WGT z&R+d|V!qFz5N9uikq#-x?aj#s-GEC3o*s%r60y;*)Ls0;+G%O93|&?i?Iu$&ZM_N6 z=$B9um+R2t`dvjLm4g4b|I2Sv`;`k$BMbX~GEZDKqela?c00ba;C9^S5hS2pkkgbS z?{2*P7`NbZO6{HAT)(TF20u*NaK0i}P8-)zN#Ros<|Y<2$d4ebR%=)h8=TL$#q#O@ za2~SQ)hUywMHuh+_{YcpzcBtL!_Vdp<2HP{V0T?T6CCQMksxpkr$t#JS$@=KV{^)G zcs@}pthF&XEmK0A&(G$Q2P+M#^<%h8Ie_y7#_tzj{>Sb%cm{kytM|ckfg|Rf?$-Ff_#H$Om&_Ard6NDSjh3g!Gq5&s`r%qlE#`8iU!L ziV==Q`0h~q{*syQlvwR(rnXszgxV}5D-ZxE42#hOYO~mD2d4%@=zJuJaFzW3{x%<7 zRNv9Mi8k1yLk_lp@qi>1MxsUV!GkBJ`)aFZDRFxJUIIQ5BAdi zis7fAR6n(;md0PW?mG8&SbqQv@5uEyT~5CiM7tcf*XJ4G_Zr*7^H#N$ZxuEmOofnU zwDB9Y?@}$z2Tl2A(9>b{Kq#3LX;#J*4&z}x5Q{OG9BYUm&kBVYu?*k#Q`c*C!X6L= z!{H3AkQfC-c&~O@S|w!BWh|rmOxVAYL2Gv~9EGtW&JdggFPhk00F|>ef0a4;z6D(! z#tJy@kK@7fu(4@tHAIDGj(B&(>Z)3#Ay<7}zY9B4G$ryJU>P<-yjsz&Ne zT}w`jV+%fBi`4b-E3@$&N#it2leF#*JW0jqKOt*qXgM;wzj5+>&ER;2Zr96W+z!bv z3U%bFXx2f@`FP21KOe4Wsu+P}i1gf8>dWDF%S+o0dzwFfyM8%D@zU0J2Pid_(0(x$aa`j;$^RQrK(I8o92xb3Z|e~>Ny|_a z$&xt75hTM?I>~ImHv%-vFeLMWTPA+dEBRF{oL(n~u`EvUJWUXkPWyi3jzAUH0Lr@? zWBIfF&uJ6U{yYedq6r-5a2lgoN-qdGWr{RVyd~3{`t{77VO)kV7{-tcOED}-;yTJa z@pK?PQ3h4TotDZAeoY#GsV=mugNR3t%Zqv2$sd8jDRl$BtQ@(AyUxV!zfJj@Ew3pd z>?c%lr=~Ed@}B+L2j}&TXk~fH_rET-0qA}b1n$?sB!%%h$1WQJl~hD7 z=Z=sH-{5;#Y98U*9%5q4YLIa*vFdSezh8$ecxaEZu*gu9; zM7!Q-zdM;2+y7|kbPr4KK23i5YY48F+(40UNk<#6&mZ8{F%-Ee#MGsd7aa(jANjPLy1 z^7WT%LkxQ;`z1k;F(A^IM3C6V9{cM(zw@IM`%QAPb$zLH%0Vxx-j-KeO50!h1#RI- z_+_Xhj}g2-;G%BRzM)>zR6|ZqAIqzK-){YO6>X3wguYe5WLzRSK(T;I?3?-BmUpI< zMR>x}U5jZ8XSH@)1^usGk8F#Qut+fUwY;<7;IIStXeFg4hiWs+)2!q-v6mR}wUghD zde-?;`S;`WSsdbU%fSZ^#K#~G#b-+UT6$MVIhk@u^NWKN;1isqub1r;Ab}jf?H%C( zJ#vA2Lc_#iwF-&viBoq(S@8_|@ad0NXh+rxQ>Y`05d7RK4`fCr2VOcNcR6x8rB?|L zMYMX9RZ6J7w-Wyw@|GLb4{bd6BnH=O`iHiZ(a_J*w_10q`GkCX<4~cbWC7Qx zr%{%#8jGo=@O|%k*bX8>ps30b@|7awVTG>>#mtwFF(0d*c&vKzvF1~w%o`2&Sv*Is z)l5#UrWa(467zMbNQVdH3LY=$<8%37Q3l$SYKW!P{n^7G-l*Zy+KHiXDMhj}18`Er zIAYMa^oLG8u^?drR3-&UVzlVC7gV0){`&*zGoriVD0;zblMbP`G=WyP)tz6i4FIWRf1{MYyIyWQG;Yx1@ zQtKu4g`a}Q>43)+)c*=9hS+Tky)LwLs=6Q#BnOw*TE!?@w2Uk2xL6TRs-9~SjF=7} z#BlWz3^xT73Mydv<^f^im4RW*GYe}$@w6xbmSizTAU=6#!>%^}tDmk-b%jzsiBWz- zzK(KGQOzrVYdiZ0F{#5XeLfH;r_Dr*&q$o+8G^-dn#XWbcdxQlMSu?=)wZ%NPHBv< zTbmGGKl1NY7|dUtGq*Q*V1&~H+6i8tm#sHu*NcS%(`Z#zhooe%w9Fp!DCAh4tubKf z>*d1g6mkmBasq~nGNHgag$HjBP7Q|8`9corE#D5<-SoL08kz`s+eA8Y1!=f26m%C{ zpoh{^@MXF0K6SP5Rg+k$s8jE=oHw4@zVA70UUuqRP!Ix376?kA7{Jjuy<^D10fV*; zNkFkbuI%WVQVsE5Cp@-tqWvB%L>^_iHjw#)s8>_JL<^DU7|BQsiIW`9<%MtB()Dm7 zzfnaBgmogNC@h6;-&o7ilbx@8`-)l5ljj9aqKLwQlW214H-+`*xNjzjRP9D)= z?@N{Ri?XoadYmH~x7cs->+x!R=&KGwtUBijhKZKHxDMZ@MF=~lP&^GtfhI+Y(8UHr zls(Zh*6`Ki2k%5GCUZCmc$&jGS!7{7=nBTr41@t$*~TY2HyMM4MIkZ`I98w)N>ErB zg}BrT(;?zM9XVT%SUyjx>>2lS*eWHO;|P`{S%zZZDl;HjH3>nx7F0Re^5w4|UikFw zI{L{fs1l<&65|yT=P*&@W23h-dDPN%Vx2~hn>BYz>rnD1oZ%epgk0YU5Aeq{bBu6H zS%P~gkR9$kuZi79`29m1>|B3t!r?{9+LG3ALK`T(J;oG<+o8j$e36gjDVDEKp8fW# zV|DdMaws|rmkFK%1VOVD23uj=%LS+U${w@S{kC_5y&q|7Xr^w*D{cp1X`G^D7T}^( z`ORznOxZ6QH7dRBUBN}aZoJVX%;T1`i36S=^rj8s;DWj!af-&b-O+ghi3k-uNMu586VJD=~$pWS}qvPs1DK!jHzVtLzC&S!Q+O)s(QP zmLwSxumUbqK<6g*v$WvUUn0z zdBKowp3(f5>!~OQy}nI}Ve_#?$wxmo5~s$D#=eOso+`GoXR zAmB7ZN&+R23YN$DR5@Cg^n0S#mREZyg#q<{0k)fGsZeF~U5&12>@Xr8bDjbeE^;C+ zNumUBaon)hkAw=xJX95{3)MnDFDaN^rg-n8k=O#u3qK5B-6r23Yv)iiBZ@dHaU4%z z0yXu;)xVxC#FE{X8NB-jKusBdoQxMNk6t+D{Z-bSIZQxNpsF(m(r=P4awNxK)XN_a z80{C@p!lZJa*$RiFq)-n<6~L(musXaX$vnUr(4P%Ap@_26-bW52%e!S(A-H913n-6 z?ALd;FliKSCSpr^jG_P6o_nC@jf&i(#g^1rS09FU*!xG#pJX5?5YejJ(8B zvrVga20c_kPeFO|4g9@64@@|vyAOBqr^63*FBhuhB^IT2ZED)9!mAqyke<&^abk77uC@`zKf!9hbzy;V?g-%;>M}QZDW2j zRe&zw{%JsC@Ku(|v(ENt)-kNGL;xbqC@jwlxP%gx^g+hqTy44Fd91-JmBIvapalY> zXkOCW-fIq}8$`Xe)>wuvp0to%jx>*E2!+qZQW&)7^idQ(+-O<;!pO((>ZGmEP>x3kl5>o5$^pj|g4?%q z)ZrS*)}E^*1xVG_K;X`&|0LLgrlqi-bFJG7^Ea-86nl>fhrl*zg_S#}OJgd?x zzc^|lPsIXDdP&I676oaz1FtsY*Gqm~{RBg-i~nQG#uYnUkJqY;zAq^(m*WTq<7t_e zIEwCj_mPYK5Mkz0#znPnkkHL!_{uUe=Xq&uBkfo^Q$fE!NDd2F_O~751KvJ9!RM6P z3EA1{=Z?Q34zF6?ZqiR{NixAD#YF#CAa2%qb3tN!eZ=Rb6z0vf>*i<|j9;JH_1~Ir z)VU{>@Hl9EL`j`z6{0N97~^>wtMj7dBCfOl>Uo@ai}oY2gz8DY#m6xYafm}4;&5w# zCN25O^3zLaXU-k3NoUX&mAv1gvQ4hjA!X-yLGrG9CtFv|FRzKJBIzj=h^qEker=mM z;PXk*DL_y%PU1ioWFFuNhFRCw6jFe=Ev0y4P~7h$!K8%n&nHEBeY7%0&4+S^qLqvG z7yrFw=r;M;H~H{-u!M|Dm>@}jq!sv@U_R1m&LPWo`@ZJ?tFM*aIds{1T0}UgzpX zF@2Zt__Xz5Z(n3e0W3jCl0dPj+m{D!Ga;%tX1O$=+kr3VAa7p;g%U}Om3fS#VFly9 zQBti1)t#`++x*_p$4{aCjWZhV;>Z(U?rIJdLp;yY%#PT^iLtoYA3# zg$b~RBkFmq@Z~3hz)i0H3Wq|A?Q4hC^;iM5@;t#SpZi1d8$U} zRA1q$E6@D7pnuq#ep)6d5yNDR!f^Pe-xOgLpkfOp7%p4d@YBo9nH-)B0ueInxdtqLe+-;d)6Eqs#%PmK{cUp7y%EEay)WJC&-q2dVm+Wed|t_>A&;P zr1ExXhBa2a3Df}9DT6_~f#IQsms5vnuPO9%1N1#m(_HocPoergE#VW|WVm7>s{L3Q z->U7I2}ofB#W=cV_ZPB<1CQ4+Oza>J1^&1`GoSz9*-f=`Q{c!tu>uE0x-uF+uaJq7{os!en zHAfP%JG%Y8qI)Q&ug*3)yZyCP%?!Lkx!^Qfc;t=nX;DbM!pDWp`oE2>x;|quqmM)v zPGSzx>GSr`Nt_=O0k4WW2I^Qlu$9JcxsG-z&#@Fv zau`G649}3dpkE6TLKE)=RWz}Fy|-t}7VR6NNhV1cF*M7k*;x3!fag8#;PK>m=6{ys ze&+P-q>?0IsNVP9DT7@%) zz88@>iQ#3ER`A{jHotY}tYt|Mb8WZ}%13hF3A@ zmtRuAL2Mnoke*2iEy^+)80&(o69+cip^f#rkaVFa`y(9Uk|+`aZ}}`km|rthv&v~- zN-S}#<)Y07T3IcV=e=_ANjeg9OVf;_i`z#M9kPMn-+#Ltx6dO;KCiEcRq>JVJOTXO%p>9RFhu%4 z4n^B4CPO=G3fClI(QoLpm&9?Fq8J>*Ilr4B7`wBoq%;d*@72ya@W^*F#vDdoppulo zXp!I)jDs&w52vFQnyx9++`-8C@#*!?~@(fSYI{UR;cc3E!?Wig;t)s6$ zHh3``{(?l26`Ep1S`q=*a`1=^?|xt2)G@}33k}w*hqf8&6wJV(oN&XYr-KmheY_?> z?9tG6okRtHr?p4R-=U6xX8RAvuy{=qjUk8+UVT0qdamVvC4y79Toh>U{|J2t=WoSr zoDg*4^|a1C)BEzy?%GU$7J|knF*Yy8j$h1`C&TcL{IJ9152E9K5iCZMG)D3mLzAqI ziCM26bCZxuu)p;WV)y2OZ>NS}h+Pg^#}D^ImNdYcnR%sAa=uY{NCRn{!g)pDC>&$* zJ;~cgeK4O`vnt=~nH6zPSfi$-2U*hxre|-EH7Vp`Ls%&!MG%4@kUYs!%BJ;?^-%5{ znN%T0dilm7jr*;iPL>z?KB$Rigw^z}v}94W(4raw=isIJCsJ6RWu0Aj#?LLQTJ%MEr0g8G-$k0jh?Kxdlz{2( zZB`%(&axib-rrWUS2$lA3eR8+OVSizc=*zN&+yQxek`2UI<0RXc2{rhcCa=o3Y*90 z5HN|uBo2@YLCigVYT{LJtbA?5tp)pxH)=Nxx7M0`a&=oSOz1xsPB{XR4%92KOmB`m z?;lFyF-jnLT%d)@4Nf@<`>ep>GX6U(VPz@Jtw!FLv@ujA=tTG_f&<>R5z4z!ZuGks^LyT-5%f4?E@CHiYMh zB%C58hQ$CYV3GVL&M0*nZG?5Asdx7~SSy+hrZEm9Ig%rAlF>yTU-?lW-H0?p8f6{Z z{n`5UXV~?WeBtXQmd9vZq$C+5VH3ENsC)CEwMx4k=R9v{mw=(vhZx%7^9XLQlH+j+ zK4*@5NySdP3+peooEe-(KbYgKPnM}pgUM(^8jd3{mSPDSXE_qrU0d5ygHwGK6RZas zKJnbkd+LP8H~|OIERM+>BQpxYNWQTh9}R_aCPSnM{Jf-KY%$+Qqnt@rM^^RRE=Thh zSmlt?caCCkn!<5Hr1nhM@KfsPOXVa;T3lSUd97UyqI_P|@^97e;}C}%A$o{I9O4j% zTLl`HFr9FtAReN+WWZR&brNg;8s1{_Vl3tNZ&W*s|4=*P5QjL#Ar5gU3BKBBm|}hQ zXjAcWqNY_|8y&Dqq-g@D0FSdWc-_|F!7F65L|EWa~(21LFy)IRtgJuw2|T=4BQ zYe!3~qr2*9c66b1KS+)bm>=}@2$Iu1w2f!z2*1sR_t@GtpZ=A8I6oXva?I;=ruC&n zr);@LlL?0~Q7-ctMWohdl|1*%hfZxBSB4T7FO zr#}Cv*n4n}b;PyI5AOt;mEo2`O9eP^p7BTPk+S;sFil_CYFGxWiu(wZ8W8_iK-|$L z8iUjPwPXzae_{lxH4%BSw!qqQ!LAP5jdt`J^4}auoIr6T&GCXbv16k@&K6P>8lwI< zUpv~tU1)u{My1o&u7?c@E=UrEOT5A|f*f)mK9Lk%YA}S(qw&NdYo*2qCbc;mZDc48 zNQ{6n6w6>bLybF4kw#;w^_h%s<`FHzTxgL5LtqR~6C}ZMI$fvcYDmH)WH6(bt#uBJ zyHNfOq%{a8i3}k!gv^T+Yz^{2nb8;5_j0mR{bJSD;43uZa^UuM`JaJK*LpFKzR@Z0zqbE&t5@Q%s=NV0a!CkWi&AaY zQqApW8N_?L5pihB{TR6VbEr3fEuRS9kW>2v(s8>3DSTJG@vT6rS#tE)9U5tCrIvI! zoKA82?3RKSP=0D+!P>}M`&Mg^tCM@6_q#y(NG1w!>~>hVS`W&@L093}q4o%Q8*mnTz`wiajX$agGZ62lxZ}j-rDdu?p+s0qpFBiUF^3iD1 zrqwVH70Hyt5+M&8@D_JGB8^WPV3yt?Ox^)z-mn-?(-UTBV%82#(|_mf=C4X;~GHShZ{X}m>GDf8=UR-}@ z^7h0YH+YFz9Oczn_gPrkDSZ~2TmReeD#Q(v;AKE(jpwrs1$XG z>o@OP*6+@pOkQgb8-rVvd4P$cOmnmX$KY;@1rS4TH7_nR1m*QrzH4nb{J8cmhZ)6dcr) zst1GXYJXo%3C`=Q-fHcR@7UPqO^ra^8Oowu5fzrDNgn433T1@5#~7R%459OpjK>q> z`F|vDG<;&s+VSaAm-2Pm7l(BCAybru^8_Z-3c2@fZrRE`$MZ>(I0VD0&hat$XNl-f zt^By`Q+qaQ^1`T`FS~PmK=s4gB`+Sj1ls#8dF8j}RjInW!EXuL4%w3&oc2}I^(slY zM%_W0MC_ zI^DoK|C8g3%Wil+F$H44%M^1;KeJBma-^&wv67wwDC{DiBH06LxMtQuad-NvO^H7C z)aTZ-pMEeqcPx_o!AXuIS(@f>jAJkz_j6wLbubLcjBK+GG7y)4d7&YixG2oPVl2mS zKp;ti=bJl8VrbT!)$KyCTL$EOer287bz$B6<{~d97{5a{z)1w72=K+kZuNq^Q$|NLn)O_`ZcDVcNEDA#6o#=RCF+C!M6B%_ zYq@6Sd)x;!N#N8B{m!5WJa8A>$L9fp>mIk?@3xfV0d2f~H_M$Hx91Kg+*f`^Tm>!; zafm}4;&2N?y_>xLC)v`ecPgUXSp8p?baeOR_>zo69O4j>nK@`(hUdQ4u9+s-*cnpv zM^k|1DG3NHLEdq_`?^7W>gn7&-fB?(KQ`x;Z_s#Fj!=K)n`{r54BuIM5>4Kr=b-f! zIE-USp5QTz<``DzHD>U(03W{wp%(g`_0T+K^74B^R8YuU50G$ylogr=G%Viv@m!#S z@7^^c_VHos=sQ37Qibj39AR)UKy0)#-J7&zkxv+6|et zS#UZSs#1HdL8NP{v5*Fq2<72GkFb?$eJEcS%EJ*qszZ5LAq;MxIYPc_1iVlwLcU^z ze1!;jHj;uB?367ne=d$$M`VuMx$!gYteR>Fbyjg0P7neRC0u5I{&~QkEo>hqX>}w< z7+aWb*8IF{O2R|5QxbX}dBYsHHhA$YR_~BzX_SSwG$L_U;uyaoicDs7NZq_<^P6QF zMi}%+P_dZ*7qwmu%Eb7*q@YZQ%@QhFsL^o3y0YR^6F%<}MrjTA8y--U-{BR`lQ2qK zqJ}VBg|rR$&FWl+Pi(tf+wlhyb!#BVvl>INl!6fohBF<%_U`(`Q6X`T`stt&8XwJ& zWSQD%Ol{J*qzH$7jQ38ORm?EN|EtvWD`W7+ssUlgGwT1SsD~d#V1PFuHvCV}^OK10 zpGAzzS#=exOA9{^rU=jbAl}og0yOIjM^bS6o2#h|E%+~rNgU~jxVU5?4kb!_|86Dc zE8W1*t^M6Czv^JEl0p*QQ{u*>t?T7LYL-~PF{uG1_ zL?~Ym$|pkk1Sr1)!mb;k{F6}rekk7^%2$K(7ZSC(IA{H4$%XM{Cp6ZtI&CGW3do!z zFDL@=bQB~(2HKK<*IWhU0>5B=?XJ_-rxYY-#w#Q%vYg0D3Jc$bKcW8E7v+AsVEu8+ zyJZ*7rCu^aB47w&NqULJ7FHOAgtUU*2OqlD#U$P#x)R+jiN5L>rqQcWGhT)t7Qr}%QbZsGq$sDDI zMM=G9E@6!hl$5nkDILuHqGp(`Sn;us+Lt_12`SXd)5juk9F}ISR8P6RMikC8*`BH1 z;gtsUHRHw62u$J3_5qKBWC(`fM1LR?I>9jOx}RZgjF5K33Z=9k@}XRW=h22*j&<23 z7O`B^dNA3B%6mwmcEBn{H7PPg2}ErZbxis66=7?NdJ zVaRNL|AcRhWltDKdvMFnQA~#>q7r z5^cZopP#7mz9zV6gbHuu0uCn6{k<#^G!EYLWzM?Tcw5<85g74EU@GSK(UxD@Vjh^j^-u5 z+kSWjQN~zTP`d5RoFyW$U6UeD2q{IzMUtfiULX}rxqgNJ;3w;$j0{LiVMX=?dbR~hrqLw%cF6hk1X{Of9^Z9-P9XQ^EG= z=ht38Lxm5>K#>f_D>#kwI5W5+x!F=EAj7;U=b?h_i@8&0&i*v44H{2!yeuf3EN~2L zgSJ-XpS5tK_aUxG3MRg?Z4h7Q?KM&({bq!$7zo)^gx4=cRz`S%`|eX$ zr~J*9*Y@ZgM+52YF)zU?wi8t^e)-35;jCv_0+T6H0W1Yr*n0M}cTz*9`kJcRR!_~| zG@yS2^n|)_oOZYb_t0$6Hpjoto$jH28-!fofun64G)3D(o9*J1l@;cXMMpy836>#f zp2IkrWN6(Dz;j&a{a#Q-HCx7GpUv#OG`vY6PK%hth%AfYENoI}ir9_nwhP8b&rbMN zGkh7HfLbyb>j+>8f6O(XAUd<1zA+9d$CW$62l_i@;0AKn$86s{ys=B!;fVU1L^x-f zAn48qGJ@$u)bm)u9_4$-`M|I=QByk={CvG?g|J1vnb3k)u7|7>-c!@>GlJ8R5!y9V zMV7nOj#q_5b5B6;f1{#~wh=B~;Qu3eci5d0-FQX&UaWkNc3<%x;*i{kc>dZ=ei5Oq zW7K@TkQkimdEgp0EbDZuKhMTh%{QJ zFOrB)%h#|~zfiMM-xcA`2tr{v3ZpSu1UP&~%#f2qrg|h-%eLU5Da7Wkb@l9Kp>Wu= zOkgsLGrTCH2d6J0MM2*vDIlYvw#{d*nU#7JN!St$E)q0J;;cf$gl)937z@Uvj%}H@ z=7OVTHG=C1nk{uOEX~U}#!5KACp_)jwDQ0#q$jhcQ-kw^9t+rVJYXE|B<0B{w;bQ*hR3EL(CcBmist|x&_||4`}1(4SGF4=ftl) z+9$wb;J=fC)3>@L1nn#B`7G#0WftN-yr{=F{M~>U^C%c#xU~Q+c5Pw1I?A5bdRG*3 zaln#5^qY-Jgp5)oDysc(LMgu=t6a0R4Jo6RgBnO%#rG@sc=+c!;iZFtkaoDj;xtDA zl9!boLkd_~{fP6IVD@sN;5fFKLGJ_iXzoR9>827>Hxx^lBCH#pT| z+0~T%+t}$tqpKc8s%32Jw&GRW#MT8)KX_a1sw>|5q%WG?<#>wYaE2sV3d4Dw*7F^% zz^~=yP$O`M4Q!a!DRC&e3YNxcnq@GGqA8lh;3~>MslJMqwl2;C&1;^njUHqd>yOWx z4J2QW5x(3JzMg_F%iCyF^HV1_RLL)CZwVogf|j+iebl7N!{1id5cO0vqE-OTh$O%X zoCDub^ZCo&ca(=EH2o??xVWoSLKlFQO80#YzBk79yrcjwAAQocw)J^)^{Ek`M-d!A z;6%)?#UZj3d2HayVUKM6I0JTUiIue!slk!HD{8qKy!?YHC@pR|k;(D9Y}cMyxPQ>Y zHT77!kW+G;lra)#d7cOa2dHwiF6obJt0CyxJ(7b`7_{dTg+#;-{h#ev<){9>B87Lz z&PXgz3lc$c5>a{YUnZdtllDo5WIMcRLIQMLi9pMB?oFs?>PjjNk=>$n{m_n!en!4Kl z^c{0P+fKWJ`K(Y)z(EjLAo|3#gM+;?d|<|YbU1k&BXNS`aFSy&M&}2LI2B0eW}s^5Z=18B z+M%!O*9mtP(llUrz_A=bawwhTUy2}E2tJkv+FCn&uV$}AiYsx2qbXLT8H~eWapmKV zfX0b_d*3+eG)3TJx)1t1&@jGGjIi*Z*jyvxk9FrJ^mk1t6 ze6M#~bt@e3e!sD3)16?DZLT4pX@M~`LTHC^5=M)H2xJ@<+HFh-UAAm%B3*iY@H2JM zB?r`2JifcZ7zd35L1ty1mjni`qN4#-#rc{q)mqd!jKj8qW1r+OOkfxu2aK4R`(dqt zU5*%2ipUC~)%XC$Z5 zoaTK7{e2|79uX_xI0G<%v6N1aXm3KKI&y47sBt5E)UcsR78lMEj;y@Xx@(T4Gs8nN zUAeZkVzVa63+q68Bjgo{Ovo(9F^s~J+_d>WelTz6M=ACgabI!wps|$qv@vQT{Q=u@ z=bzmZ9i<@^5l$snfkgAGtXcS5Afz>j|AOwU0qzc zIUXOI{AZcwzmNa6oF-p6tS%YNLq-c#!=N={6ndyF>zW#z*V2h4&fkr;ExkW2V7B58BG^ znALRhuV_ODhNdWjq#2IGc#5InD&}*cW#R=@JY=(Of35BZe`^D@CFB5+GEfAD02Ga3 zyS^J>s32A_Rf>|#{-?+#wA_EZt$HW&f4{E^CwyXfngYBcvI-%PL67 z%~Hwp{JHKSP;8;qr{EYN;<8N8y481SF^ZL)V%t#>Uy}Hu4K3St5e(;${Kl=F1#ed8 zNBJ*LUVhZ5G4vU=1E<&}RSiW;wdZh^Q*5i2Hf(iethQ2SCWPdjafWAc3>R@0oSvTf z=77agSvNE@P@fDHq7?JO&RCj43_)o#XmJLxXz<-l(hiLPd`X?iwZ`Ciy$vzXGK4*0 zr$W_l5rTM%ZS|JFzjv$(Z%84M93ue|rvOJh+B_9%hcoMPgK3xK&&y#yY;J{n_azXD!>s_Z>Kn!Bi(7-< zOI7jxp!g8|tLgAT#cWSWJx@9I-Xh73fsNezt?sXxC#Tx**{O?ZYyNG!i65IZi3XY*(alGC|}0 zPum40MA&DkQLfkG&S$jyFg42mI~5bJloWj&shorxybf+PJ2X>-{SS|)F~WRl`ShEt zpYis@2Bmecs^PQ7CA5z^-QxQ%)^WaB&b3?3p4}MZ`izxMiglg-Q~NIx{gzrn`x1u4 zTVx;JEc?p@@im>GG}`v1MY)dam+(F_-sJndwB!_V`tqMSAO9)6%(P&#vu-ID1H3jIDYQl6!Tb8&*Sj#q>JKo zPwBR+Ye4ef80NF9O4j%IK&|iafm}4;t+?@0+d}; z?LxB1P_jdlVW#cc{rla{$>GC))4U`BK@aG*7N)1gq9(~FBilg zB}EAUz{nhf6FX-w;)mVqP0^Gme^IqG?=VHjY#9wt+l;5UA%B+%8}gK*2teSBAo92j zhdg~8DmqfWpz7JSw>Eb?zhj*?eyK*?IJyXyaSV6ojBR+Qp2kpXm}7VjFoMir6p_5^UaI!s*{Rye^WBut zM-KelY7A~e1?c?^b%H1Do$A5)JIe>ZFG2dVEg?B#7G$qc70Q#4{_ro59YQvg-v@Qm z1?8WG)?6Bt{~hY@2WtAFZSX6Ln{1n^nR6EkqpnVX)9v&*cwO}Ly~f}aeble89s6^o zVLjhmeKJ6QN(2sFoN@F4F2U_{O5Jm0&{=TH*}&le-kj`_U}YEZ31<5+3ATe7(l03} zjTQ>px6-yl_@ULX_v%6vTA}uha65C{4iE4NLmd(=MVT=ik9HkqH{ z!Ii-I$c=f`wqwWYKJTtGx@LE9Iek9haY#9CA8`BnjB$xM*>l^!Qa0Jz zGgT|KA(YxD1*fqO*=x4N4}7q-bBEjY)LTJFcM@|91#aMRN^PBP+36nI(*wM~ErCA1 z91rOAZmVuH@4cF!&04H>I0cP)$7bWkufJYTJ8RE`XbjHsj*&w42ynO4Egx-v->hz} zj;3l@N88F;Z(LAS^&zsj4uZ;s9}iSh?FiSlP9NyK=hQzgsCf-_X+KWCaApFf7Fq7)ug7tFK^z zdcc2z9Ip>;zYN~Lcl1RostS%_d5p(tiewpvCg2*l4FRk;BL!8%R@;#F%d6hD(5lC~ z9zULOx*Z;t!FidIfIvyokJtK6ER24yR1KZ#Yx>AGc*obrCe5g$J~?0v!D$gRBaxJ> zP@Kp+WZ?CAa>i7u)9d)2HT6@p8SgqcAt>G3AsF>*&o!6}9l2I$xc8n2-Z0mo!FnA+ z33owx4$7Z|TpIig<@Z7P?NI(bD8CWPuZHq7pnQKQk3;zvAp9^F%6p-_1m#;p`T9^k z0m?rGoy_+ewJrLoZT2(24&2pUI}rY7L>)2|?&v+br{MAW&zLO1(=J=^dMo~3h3RtS zbV@x0-hoY{nj-RAigIPsw1nu-RA`T-Lc97#fmZLQwjZoMdB-^ofvqSD(_D(%!BBw2 zWJVEj7Ju+^(_YV?+f`cnI z4?&U6nF_baxL5d(uG<^k?+T^7-Xfht<)SRFs5T2mL^;|yr!jUJP-=i=KS_{4CenPO z-jDQM9IwTpB==i^uw}b#)VxRfj<2oBlCumUge?+9;v^?gI8BL~u*D%ypVMednOf)4 zw9Ntw*!RZB{Gl%=zqGBbH|*WIOKNHop%fka@4|ULkKu3QyT|SH^#xwv#bx53W$w=? zd$E)T*K&i9uhDpG5Iz5tVL=iCNtaZ)8n}yD9xNSl#rS>3O)}4Q{v|>Y6x?x(2vgV+ zDyK6vz8gwe*iu{}Kx&LajA)73Rw`9iUCmd5#`!rlou{UnHo~21dKdJ*$r!wESwuff z5YbuGewd;hk7(g$b4*!4wCu2r-u-=tZAyFf3G#xTrYJ|(oKe67JdROLUsk8U^=^Cr zrM=u^lpA;g(rcMjc%V>#&C}P|)A8!G6zx>~B7*Fz5k$3UzwcP^(D2Sns+~{F|8JMA z17ZH_vsn?8&lIOyc90~`34%Zq1SU>++P7)tfmui`pOetSxii8B)80QBqetv@#^Sw? zrtiMCbvh$-obyvOBO`INLJOQsQUn`mWd4ATj0O=}tiAt7j7Lpz-$#$kKHG`OT^7$< zn16Mgls_^BH!lK^2!+5Ip5ghQ(_8gv|KNtQOXJMXzk*XMDHsc-{}gc*hkpl*zQx;L zKujF5O=$7w$A5lrD|DdiP%KUhlqg9UgDW&_q>zj(`e$2*pFg~9czf+hA>BAxa^Tp5 zC*OL`uObLjwD+_Kq>rZ;w{ySR7M8tG|Ibz7w01~Y#6^Z=a0#bit)04vRA18x+rZ}a zz5#X7N=_KX(>TNW&nb#zFjxg?YPs;8F&TcdrN2LJ?6kY=`r#~WPeKbUE-E6%)8x$O zKX`WDAKnaYil!71&7mv`ezQH@h#qm*N3}HRnK2~c;u3NlK;T6Q=K;--OzOL#F(X6Qbl+3wFQ-TkXsE{bRn@7DH|HV&G^2kSvB#9H+c)>+s+evRPtHm@O}1hfI;m zi?zN=P#P;#GDJrNn+z9iscRP3bklY{YAG~{49U?FhH)$}NHA_`sd8cG5tDb(mhklT zqrLvNLn4vj8gM^mp(v4K0WDDOU<4dT%fj5YNiubEz;8t;KKk61E@c*mrO@`>8l2*C9)ypqwflNsq7m0>{Cv=F* zO5zZQBIChGc&W6t0!&53SLNbU7!u0I`yC&TIK&|iMS?C6pFRk|KaGOYL`aTchVrn@ zdpRggi;|vAfZmJ5N0<4snRXtpl*`THz~@!n~N#kYqPjYBn?_% z+^<{N!nazfs*S_Lso_%?c^VCA_D9>*`^vE^f>wnh(1Og9BG1EG72S-eqBHCtJeRuY zp&{B8Pa*e51tu#jg;NAA0fG|=&1A(s>Vx^jnpFwfaG~zK>|usF__nFM{qyDIYRj)k zw<|bJl01)dIKh%Q!NB*D-I+l8z6sUYO7@q!cO6PK)W$Ew1$HR+O2Fmx^%Oil@2)|% zl{M3QC1}UZ9%K09qM+s~c52~ux${|zeg-{Kc8(i3JRB>DB*CyO!wB&F^-o9$S+L1q zwO1)`Z{^ycT>uZzEsZ=6UIfV=cuZ*Gce#YJFe>WVZne+pxMxw{&Dsvh4Yh(~AaER` z@D!=A1x8Qs8ma}Q21K5N)(|}I@NIb6{CDm4!NLG>_?0yMJjjxRU~zclJ5@0tM!uGP zPQzbXAA43SVghn8QKX}*Qvp7w3-ks2Sa<(kwUgJV$)-9&X|%vW`WmJX z{}%>r{%hG+wcPZGxG;>9N}3^P9_LvG$7oikW0b3|$z{k@-_+iC_N+mhKGAT%PW=!m zZih^e63fsEF0n+55caa`Coey<2Z_}Pn!pH(<`|r1 z30&t2wA>qk^2#7anXorqr@T`+IlNzBoR$ej1iVDBEWE^LC7|Yyw2vD4ce{&3SkJ(+ zAo3zkNFS8AbAv zXf%FmbjZtSVC{d}m%O>)Vv2tJe6jSkM`{}XWN1jHb0G=Q?0%KSX=O{vd zZ@pL-%;a@Bj4N? zmO3Ia2BSntBsh+M=k(jdsG>XBZ!^|h`Nu=`!WAvZLaxt2$`}DSoD^9=I-IWDY`B)D zHOnDRl1%#;Q1d{88MO?-7^LvZA#uVX`Q2~z1`6=_{V00peEyc#`0>3dnu%4{J44TR zSIrHjy1+C;pGc`8#`kU%XakpNU)%fH4}aYqUXzVtaUcr}PLeDIyEDv)xI=o_H?I2d z<3mfs>yrVJ=KU_$C7cj{{%Z``;GNX8a)>%$+C<|HR;oT&?}7f$sT@dIH65-lj>JmQ z?($ytUJq~HAm{7Vjz+6e5*WsjG{ee3WJk1HHkj%0bu#SlI5WcZWJWoSnK4d#W(h5y zu_Y`cD{8%HJ==kHmp5_RiyP2BGzo&mSb`#17AJU;gK_5h+`zAFBu6>O{?*x!scQFW z>v~enuig7qwWkL) zuB4}4f>nGhl9Zls?JWrE2hA}utawI%s;}OpN z3J!_E_GfGC`LRl77{8}DPf-MklYXk5)e(~GRUv&vge+jNedydnwYcO6zMv@z_66NI zE&ON|jFMn4KY8fv&MP%c^j8QHiDU^!Zl0@PUx#eqr|-NeZAU(^_sd5Tt0APmFebdi z7+kT%7~OXk#P`~WY5&((mxrR=dZ*cEi>|Wm_g*;ok;N3A9>)oa zl0{CEFiL^xak`Ny0z&lIuRgz|YF1`=6C@62BvRpIlHdU>8E6_c@*QDcGv)2C2Pahx zA^mWJQGUq>&P$@-O*c+A*wJsCU)Zl<*!k*@hEbCcqwVsmm-qjktZlv(iD7RVa7+?u zlHn+U1owP(<;=AAhnIOeezOx6n*2-panDWW3A%B7X~iKbB=?{_F{6C5M&)aVJtG1V zHG<>?j>9olmRa~LYIYhD*%_Rd)q-0S6A|OtknX^^i`9iuT<9u;;V28i*Sny6ip(PAK0S zdY^&vaO?xv+aRoOj=Fr(AQ{1#8=$>pG)%USt8?-6qJ1^=2q0VbIBraK%oRCOb1TrV{iol>WCqj|$q4H?HZKnPGwZs0Hk&w@fCx=2fET?b;#{rC2 znDxK6v^4AWsA2Q}**os|D2nb~IwT?VawUWgg0j6Jp!D7nq~oz=HaWNw?k+$C0a1}A zilU%^y-<{*f}kK+;S&)=Ktu%*M8F1C?BDNlyGd^D=1LNp?)&H6?B34ozL|ON&6_vx zsZZRePT&J-+K^{dPPAY^06ze|%W#!W#i|YE`|MyHIj2(qH-@r%EJ}*JY}1l0p{$I9 zpz>fX>7H7iq;l`+PyhhfG4ic#!Q~Yy9szm24pbTCIdu_myXw)YeMV;@0YSY(vmtDdI#+RUZ_&R&9rl^1rvBetkoI?lcttu}(_xvS|CQ z!S_c)yCNuo@+5*0UF>muliL41)V;KN>Bb7RThaF7Z3liHZZ}$cFns-efM9kO+ma)ZPdMY*0i#wJF8hh)5@Kjxg$U&8?s;>uDqzB>b>tZ_q z{kh8S2zAeOR2BJ`Yusv)$+6ne>dVJt*pX#fj*u8Zp@4vm`1_g{x;8$a057-OMOmt} zi*YH_F3u%SyDGBnwutk3RY8jglOT9UcB!e`Q>*y3IhulXIBcd`oCcgA15uE8sw;Eq zBS)8)Q`jqHf@|6K20+&bT;}&0aFsB~vW?i~rnbuXSDGwCZ^RNj$Iv{>F&It}6b~;g z?o(y<62$6dx#^G8w;ylv1==f%B^ZB*Ig(*`o+m>bGv8N*c_XAF^a_)&@y8D&=W4rl zb3$#+P6o39m(No?SdbU}2)J(eW~!*)K-gFdb1t=T< zG$rD&G3ou9(d@a8o7}}0KD%*DX&AK7Hk=e;o9y;X@D>UZ2)Oln2PvOyur7XJ`Xh#V z2s2qqjMw+8cppT9Si{^@R8K1-!4syH9b3*ia#(X=>77_+?DBa8$)BiQpf~_z9Ft^* zCg+?v`tlp4E<%%%!sF8ZO$^q&8bX1?;J99uEvM<_xXL>HFHhNMc*>L_od0#l3mWeU za|&GUFj;`aS28@&(F!ZW50w%ngHi?qG1apBlB#s}Q!`?$P?K=OIJ$TE-z zd)$S<9vRwJ#S$8a^LXSx)+lDf@+gPR<+_DTK5v5<^tNYz}P~WI^SX zklWTZmf&)0s5}I6RV{!{!9EJfw}H_99R`&xP`PhC$ovkOCv9qZ&X``=&bieLO_Q|Y zyULW-X>3F3?Z|$cvM5m!CE*;;O0eJN`r6@#_A1lR39l?@eoP}(sJpcjXL+05+sEZ2 ziT-vU@Cc5a`t>{YSkpg4n`g6Bd>b@?W+55mYSaD&DP3lF)_i-yY_>aT3bQ%<9&UL) zkKL8uU-0_+xMVP8kkUbyi6m4|)Mz$CDoVM7x{4fqI=pt5f_R>)B(I5f zeykmY)1nBYSg*tNM!T-VrIEl!!x~d(kdyY}u81e)D4wH4Tw)l34Ds1cLR!V1GktR7 z=sGtRM&>ILNsux|3Y1KRWPVWY3SakgCerffl)Ro=%`?NV@OX|=1R3M}?>+dXlupYh zRM%t-l^BfYA_(iPP$-4MB!YWw!(D@vj+2r#yTB^!N}I`K8qKChTk+txev;NLlr=_TB}B6wU8IRS7Oj{W2qzh~6D;}TJ4K4!(Z zf>?l{>@RWFgL*!ag)P{*Xq%~9+eLY6duy(Shr=jX6hqhquNQcHKvqv}^#h>Ldy`8B zirod|=N1f9>Zhiq!>3#SR`I70hT&KBowTD_JoNeZLF78GmbEmK@c$O*Gm0IiTTk86>ekVSh%z(->p7cKQEdHn z)BQca_uQ8iL$m>gWNDlw1X0AoM;oY))J@(r)qVECXPY0ggqk4A4q?(%iA^T3-v{JB z``o&@eBh({2prnlJEk@_wOIY@`o?Jcm6N1#o8kad?4kqo_4b$qT)s2a=HKz#<`YPN zHqD#62ZZB=XwQ{>$WGJ$&M=!qr3qTWEi=S%oWf8FOB19h!##tx_5IH@qt8>zAKV&4 z|4TB#)3QJj5{HNF|KUiD@qN?in@2o+;bt5nWyrZOoU?T+0MZ2D=_yEp4E)D(72uN! z@`|0J+u^M*j=#3N!+c7N>t*XCF;SvK45tCXY+7=*?ZEWe zrOtvM#+h`fTn=25{CPVpQ;B@6j0CJC0hv^AjDmwo+l#I*ZF^YbYWB2PwQjQ@Zq%?qSJ z{@gTo{z36$a#y3}J znD}J9pDzhqu55FA)zdWE;W!%da?n6cB3koJ!Ab4TVfEy61dRY@+n3^Z{oR%?1bC(O} zz(&z{V1J;i!z~U3lNZ##w{uP>GF|gtyRBJp?JX}7VN8gxNHm-@EqHI@Ei>PVay*0Q zIDcXhjKP&ykA9pq&F?hk)-fMy4t|5tv5Y7{5FEuT3MNyH-)#Hzl9yjkh9fx5zepbC z(dvcoSM)swLAbI2*MsuYK54q6>+z3gkJOy#3d%aTEE*+75G>D7xJbyd7LBrYlObmg zJl`T!+bo*?S}^W5BKQTSL$Oj@LoWo=?WWRuUz(V=+YH)$4LYt3gEJ(Hu?&gxIL3u! zFu7-Qpz>NsH=eId*L?EJlA?7HlB6)4Kj9e8F${q-A)Z37s1pPr-Dkfy{V{Uqy2G`! zg8_#PVaI#P!2kxA0RRFii8wiZeCJv8$0MpkCpSxDL!ho#71XWd|Ir5o&YNiGn=ki$ zCt{XBjt~T%C29Ww8#qf~wQd2doo89nB)A;f2|t>XMsG&G_+0Wg5$XaT1= ziF$qPkyEzaH>7HA5=Cvpe|()vMv6z(TTu{eR?Ty0H}(srW5?cZKI)gqr|dA2P$XWF zSyGTbod~*jJiRm#j)l}sZ9uyY->+;;rm|7+yXkt@kex~WnxUs+`7>S^i7_$@7>ZYf z{>_^0x&IzA1(lKq7E1|;*|9dt%WA&R@Ob(Xal*+GrM~}Fk4%&V!=I+l#&J`({GpA& za~Yxf3eIt=d;ielLLlb?rCUjy|EP{qQ0haJv<~o{<#!KKwn= zt~Y{kG){V@j%N+lCxm~Wj3k2&aX_^gRXz>BSSxs*+^X^sF-kproab=h@p>4+7y3u( z{}t)+eP6WeA=*@o^JsCDdbHp#;}8y4mn&v${}?d^m7!oZhTc$FhQ1g6?r7i38e$s{ zl`T_I?l+9`eyH)2QOW+Tf06sWVH7%46|k3ieCu#^0nFbQ$7z$34Y93$|1>SW@N54z zFKI!)ri3$K5E76TK?DRL0-M+2p1h;~vDV)-o|dUGv;D@{u)z?%9LsvZZyR`IFIG7hdbo%mGWongaxe=Ln2s zMI5ldV@rm1es`@=ll|k>XgeB)A>Qk;FtPCVsbn+Re9^#rPMIL_q@^4pnV?;QeBirv zgt*F|%n^2==MsW(bQ49YdF7ACcXT|YwY@Sd9c3U394B#{py1!Np=XVJ@3k6Q8s^&} zQ_??q0X*=o;QQL}Xr%`KzIAB$>tlvijrk?PkZyjW#-a0LCTX^k9F!5x~y)*L7BJV%HeEzsm= ztvau}IW@gBb=bv*!g!fE;(CHXhf4`*7pYz-0;i#RCF?_ti`gpfYYbM>XG8yk*H$y2 z@@DAz48)>P1Eva23`-C=&M|z*wrR2}FwXWO(}C1C@7uNUiz%gA%ABxT3MH|OC}9-N z($tqZp@HTHu@vnGfdfopID!Ne5ceM1mbc{ZHJNZC*S=8* z(6@@_O5aQLTph&q+LxF&)QNFTXf!l7Z?E>%Qu{egMQt5nk69#Wfd?WS5W4d$)g}@~Pmt+TCn+WpluBnHn_iVUkS(esD+rKh`Fq$=8 zXC8jvx^_2R7b(~~&T=v*OEOEy3LNZx=fLndv?a`J*)k}lU>!QNK2MPhPtr8YlPn+N z_A>TeHHs@z3en~z9k1KKJZ6E^y`XJng16aS4!aBFN&^KafL+L@%|^wH@d9e89=-QpoxrZ47=P{CEIf7#-j)8k)i0ZXb1L=fxgZT)*j$0GbpWQU<$nRrzsiostw4?rMZ!5*mSw=R z03IE`s4kxUeSyB}9(8o&nzwPU?_RhqiYF#RU<%IAKp;W_2=@6CRrgS{)Ai98U4M?n zEehua8skYp5@=;h->L2QF1x?fEox;IpP*WKkxpb)v|ji*w1^sGp3-mSPaB6t?k!QE zIac5lQV>bFw>~$b7AL@L$!1-q$(p;vz2QfKfZ-U46CBUTHql+=l7T$jPiof>*T{BPGe)j;@Ncp@}K5T{2%#TKx@{QR5UUTXdpavqV4!poA#u{1%!^T@64 zO?QoXX_s%lr?&C&X8BsrY)%MAJ&xybPUZ-SWr^KgKmN8bcT;8_RA;P%2;N;DALDb| zDrhsTAESE%?2ZFD=o)H4%6~n4~yt&6wyY)lW7iQJP*?N_JT9(|J zDqe(mUKev6Qe2~;=6fbMbZSGJl|LhNA zO6}ia+ah@dNSs9TI3*pv|Es?`j_;L>T2Lm&IqPE`74e=EK+Bp!^YK;8AxBDN`mzF` z36fSMh7(gh7=1_irAf1xttJ!A-rdag?3+JkIMmq$n$Mqn&K5Hv%R3>~u3x!M@n++;LNG0&NFaM7}L zk%^82f@1;3VzeOLnVYh*yrwzB7MPeP24qJeda=3i{Qa}%^e00na+Ju+`M}rB?ec*s zz9PZl_u2hmCQWYd<4Q)&=KWm*Bv{idwh@tNxW)XdWzRJu@78?o&xHx|Pm+`kcsy>8 znlP<67YH)7cFdFZ7tW=RLNrm$STz&v-vSjinRe1<%VmE5CQ%sRCiOzPisweDZ+49J zRyD+Xz($)Yx0vracEcwdGc@~N4%*Nwh(HhooDex)d9hKCseh8!Cc#W%Q5BE>X!XV0 zp4L4NRdB8KP-1M$hg;0~!}pHge1F7KM6|%-JSk%|FNd5WGRM7jaH}~9tUR(MrFN)v zQ9IJ^vioc}MZw!_s}sW;h05xlZmwOoUfQ>(BiJ@c3L`21_8LWDOo-_E;P-&u`t`3Y zVg)qAd}{6D;oEC#EdEAg7?T_pkR49ZpM|BTL&*2qBoTXKzp-s&${SlCOD>x$DFGdyT50DV{Tp;p{5B$g>>F1434`BlD)ouP-B>Uz4b59*;oS zfGGEdvLwTM(QTlzC5pxhyI94WWgT8T!gk7}N|ucmscbYXGIzc6k&cHtXsS;bhn4b9 zOfrel0>LwaEE2Q+8MXaH!=o9Q5K#!kcsX0a>2NqH+W5QA3?@4p)?1)S`t@N=516QM zG%n$SL~}*Q=Co+IyJLoSsyjU)7*`d zd$`X=UsF0ARzikqhx&<=lY()mO=X3dV)*aw+^ofWX&p{OXK0&06@9?1Z(xxVcvOU++6|c&jN2Q7Kdg6@Uecy}t}z&=Kr1c{YHK+cFOtCM4Ov3r1txq3 zKL^2XR+xA0+1|0$waw6GHMcn423$Um->HM5NQz<s=5GDhs>G9!R63l{-}8(lf5c+7}^67 zXBnQxXdI(iHq2p=Kj#I0wLtoQJZ^Ts!CpUUeZ+B@4?xnu>e%ax4 z4b-+=w-`UTQ6;aVg~NJtm;LS?_gOS6MC$~Eo=9MXt-qstvCC#>sQzwu;a81^)E
GvAr1Th-CVj6+gVjrBrWJdT*0?{;^MYkL=zEY1;K4 zUt~#{B{7MnL**F@R9jWltK5sT4fV2l!0WZUU4uRDe2?IS z)m*GWKzkWpFL=XlO>*SdNHAt*o_F+B@AivfI`9J1wEz|dUl`R)C+6$ zMzS``Z*E*QEB|fgZg2J(wdq4sDACI=XmA#AG)3|>K`cI!%XMB|EkUFDHBp7`8)jdx z{Zlvph8DU!!SXbTGZ;s+6drOKVt$QiO}uH|RCD+u9~H^a{|wZ{aa&P+TmC7B8Xf-v7)$-y?im@PO9Mg(1VyN#V9ak9!hu2`&i?7JLQXwQck6 znYWzCjP)Gr!3utNnIzwBo;7SglXoierXowylFU;$8M>+17O@+>+x*1i`K^B@=};9R zSX04CTNkfypj!t0?OtEWHH^ntAOVWQWvRrk@Qc5PF3KPCL5e2r>YVk3#nHNH+;6+) zTr+(CmJF+Q?>%$BPdiLKw=4!}h!G?qGbAqHyfUH5E&Z?mX;v024YdFXRRyuuSJmyt z3I~kA_+r%$e;<0au*Ym!^+oRwxwT!^>_4e+I>FYu>q&u zm*;c(y1M0JSU)~?GAWAky5C&;;M{#1YBmj{yasevZAoCu15Ux^vrB_L?(snK!D?(9 zTfo2!<50$R$b4X7orNir8=%A&&(NIz02j&$((*t|q~aQE1R(%`cR5x1cH zmRCi=DN2#4jqH2l+OP{#hpUe^*l9HApu^P)Wt`xM8N560raEhKLiax)59bn1qo>^g zY!18ESEuE7Hh;jSBuJ@AdLAMUC#a8PiORzfltgcPNnUTmXM(~D2U!=>^{$)?-G1P zo)WL}!GcF{0w3^rA03>taZP$!k|uM7JJclw!VU^wFB=4(nRhO9G-+HBvR`R?wM6;)lYL`kp?V?nAD$IYHwGIyn( zOAD=9cG|d*qa2To8)$ReV!u8=MFg@-xJx?*JjK{{P0?ecD}Es5!n=D>+cvYI3@s( zH$c0-Zo8{Da1;Vh&$)g7Y?Hn|C7K&{QWSi(Ku)=77|upuG@LU(@UnH(#EuceKVXW2 z%RJ30Bnd0vGn2#PP>y@v{7_wS-N2``mByT;P>xITR3JxDce}UH?G;1^$ny!(gqys; z?`<-m&X&EOh+{MFzQV|C`5?G_+dfq$*T1yZCLMIp;o`3$&YM$<-z8rfuB{+GH-t3; zmUz6#1O{ZD5OEQw>;F_xcg^AZqsGdP<~f1-f2?NUc*7o6H^i#t{cN6Ve}BfcZM8Md zlyGV_gWJF)!BHgmz(B!gp9H$OorONT6MS{e)3+Bc-&#%cWlX+A{b@A(YOeEwW32Iw z#%T4TG%%XPVE~YnEYrk7*W%H`J~&(h)=lSkt=x-6dp_R!9m&BsUVxuN4}c5iM)e>5 z^X8`7u3WiO08&(-J@$J<_-ar?V@`pS8x-A)sFw)veNafQcaLY6q5 z{N<+sci-~bt?BTlX&qxQ)|9iND9hC4#@Gf%g5fW7%^pe575){`>y#0B87LHvi*$(B zX);u8k|Dfur4i>Z^PNh!Cwer{R`|QZE{HLjkO+*TB%VhZ_BTP;0X4V@D$jvv0Ivbt zgi+GV1H91-Gna6_i{UH_M#JCcJ07-s{`onAcew{hs&_f3$Q;44GQrT~rX^?F4osh2 zO7ns0DUeyUgK>1m`j5HmBfY-)--alnvLxD*!U-5b@T7<-Tzkur7oMClG9#L()HZrh z8(PusqoAT2R0oW)a>@kD)A;Kj?t2@(pH2}xOJW>Gax~2{AraW>sbaYmlK6?19~`G2 z$YnI*pNl|zNdy>6E0ioS*h2SuifsLJ1}c|`mOZaq6)$X1^;I-nxF=@4CB@=yaG`s< zm(bDoa1oPeg~Vk_hT}qYcs79F$qz4TLOUkS(lx0Kv+NpV$Pkib8J44QlBan#G-QbB zrNHaojf|jN-E!{dub&vXGjgg#k|!yOqd7$)q@JHQCgNY70xZynQ0`@%qhU$yzE?fMpp%P*@(Bwe(U!%S!$q zJuEXU*KJSaHZ*S$IxPL8QZ<^;l&$1gV)tT~;IvDA+lk-7sO8>a)64Hy7-O{jmuW^> z7GmTrAHV-b3f9h02hfmoE^$ECP!4!0!u zw>!FgoR;iQL8>|R-OC5?LKV-tF8Dh$)S;50GK*P_FV2+HKC+?Z$d@~&UKpX7&&NeJ zpK}tWNUVU7EJs#5@k|dtzk`n%R!ChF7d-vS{&P90ec6;?>&Y zNo~wyK^7Qe7l#xx* zQx69~5&Q>IBnj5w8meo9_AzU4Z7k`-b{rk?XvFg`xPmD_A_bhF;eE>s2prndH5PeE z-`m!%4fA1MpOAlDk-!KtElW5@kVJmLl4R0vAIf=O}i_$0*cNc-dKtF|vW$ic1jSj(`td*7P;PCsqzw!eGU10VJK z>9dT|zVBlBw$nXR#_Z4}(FN2Ia+1Ytd2WxdkH_W!u6$p?2QSvl`JwBBsiP6^)aMG* zU9YtFxmuu)PDhAo^{{-}?D_ex6=*W#v9OWzS&U_Afx&@DDdRf3zuWlZxU|9gaJr%) zKjFVQrh8b1ezj_0|1M!P0DtC0o{g5^caMq(qz2j4AB1N^I9`A^bG7#BUt;=< zK@Q-7mT4WAEMJ91T*#B z>p0fDeCDZY+U%U7>YC@EAaI%rdZ88S4Mtn;UHJI?8t-efb5~~Q8!(v7;TB{yCx)0CmXxrBM{Ltse)i^(N&_Rc*7Y^$DK!>Z)9%VF)wY>9uJ;VC? z$gM`4WC)U_d7frynhesM{>G+f+AlCu>${F~HozL>J@ ze~tPZVLwr0r9U*^(!EaohfXbx<-8V2OCl!9BoIX|*7I6KoNq?N`CLWo*8sh1Utsy* zz}-8W42>3vho)IuAD53L{2Bf{g5>kUCYF{69NHV>Egi>pdF0v2O`r~jdIL-Xo?@Gf z(+tn^3`PKK?y@gle`w!ZsV2l{YZX?Haz9=`J=dU$W@LkyyKAClOx+Xj7TU_NmiPQI=9bT!RObT~BEFI1AU!!MC+URy=ap@XPQwoIDxlWZ6md#FoHyKBqISr zf!o0pNV^c@V+L~wi?xmL) z@-vP7ly^z-^LSwM2po;!oCG9-U}<~(C5s=FLNTxq7uf%lNc_@3L}w{R9xfq z`}Y>sNH;}kNgFY>E6HF`j!`43_@pUZA6gVGvPe@7&0}X}hccwV;L(m2kT!qlj-i4l zANaiRAR3e$9vjLHjUcBRh>OAL+2Ij_x^FbxZ#ng4^{FFgX|B@y!n(=Rw#jy%3wXUl z{jo^cguE{eKk`{joK&ssMq2%gT>q60#wgc~6`cPGhQ*cx%WF2x&e!JgzOZ7I#Yq8^ zB#gpjnV;3_+n)~oTDrG(Ka}ctwpu<6r3;kPEZ+>>2? zCL;>cgaD&C@mg;0zpK$1>n_rW%(+A(zb9gip()JK(q2{nmve?Ir5{kB#aYm}g=Pq; zXnys7OMh1tU5u5y|8vdo_)fLIr>p<#4vho&f7fdZ&YHph*Wzi&S;7A^#`(VRn(L7& z>W7Qv_&y!M;~%iJnYbmV-3m?K7KW9#n2a+b#tJft$t#S%EIPZnZt2KAa(e)e9T-?X z+J${ z$E9fpwY6Mm3)BH^R0sUM>A{QWdaC!n=Hw1LyLYS}j8CYF^91$&1hpP54vPdmuiYXVhG38)x|CbkJj*in8 zDB%*#3LSLNK?fal&_RbQ4KDS`oTQ8NehG;B6Z9_DK?fal&_M?su5u{bIa_AA_QHuh zx3vxvD6)JWc0uGMnPo|V=1Q)~b`Owzi;v`<{^s{Pjiu^R_4t}!W_e`6+|>6PqN7xi zG(ln*&GHz}vNR4ml8)IMz`r75m>3O@SdJb%UhmL*5n|R51V_>|Lz5KE;$*ymu#AQ$ zEq`zGwCX>wc4!mjH$riag43|CR$u!dG7sNM%jqKz?!w=X9H?6o1e~WB92aP!`{>8( ze!aPFhyz38*}+{@4{_+XPX&jP(Xhti8UDZ28$LpZi(yHgW(bNPX@XI zB18OauxvTs!?iJ^S?KsGm&BBlD4YizO;e@uOl|VKC9QWV|a`L_y{cBzv&BlhO#uBy9wBVCx5us^CsGL_T@b=Y^({hug z(Vff84?nH(vB4qi$tl=fGlur^z1GK7I+|f0jaYp)%G%v*$>{XIr}AFaj*y2tqfU~n z%`JL?XAizWAe?b^NbOtsKyF!wA9z=V%%uSk9k09wu--)d}I*gnfzK_%~p zI>F_Wts>vQa+TCKEZdAV#eP=JX{L9mdzX{I@IZ2Dx5w8H6nF9DdlwI$I<2?MUhQdJ z;nyJobhygjf2iJtS0sE6jjwi4e_iSQrZM0*EF165ZPut;#A7%(En*TQvMh#&9K%UK zO2s!Vo6K3R`nN^aa|9p&iIp*#kwfZsA?i*v?6Nd6+&I48Fr*5>;~37e1Wr>FOK~A- za$Zq215}LdU6y}_zqqx_t(sH{lO@4P5qL>sg0q{??a3<;3PIfjrJX-l9qf0FIxHA1 zOi>L;F^2zF2l`*M-ri+dF#EM(^M8%FzLGIamJ}9<7%suL4c2W)k5GK4TkV#v=QcrrM2lRxpB|P%#ULw1t%yTkRgNS)2*3^ zul&sN;>l%gYl)^%234N2qD0{`!2^lGVFTiisv`VVGK!L)TPFPW;*qarAXlm+%iuiC zayWr81V)G0KWj(rtS>A!2jBeZU&3Tj_sKSbg9(ylL`~2Wmd6IB9Uk5-g`s)HrE*-nRYl*?mpW6VFMpjLq)tB6^AneR)2?2b{p=o3Z7ix5}r2nRq79 znQt)xY^MU)*)+T@^rU56of9Wq>)MC1vq-0D3I)#uyDPtEk*g#rjQ4|4jaFx;4@uO% zut8$1jQW(NLBsifCu~J8{uzeE{h9{PF<7W|1yg0hXhaLAET-zMgkd|Ip(kE>yB^|TvOL-qC3)_0Uav}X# zD(s)4CLl4S)rf_UY}7pf2Ok0bl!5q%EiT>{j90L1?cR@k|1L^3uIa%m5d%~+n?XQu{xZ9 zGT!9JT`PINqU~x>KhEn_1@$9rAqAh9|Jl;V*=>Kje(32=GdxA{3{CO8KY0#3-FF6Z zcNvBt$G|U^<;ONOe0eE)hZVyZ7Uv0^r5KvVF}R8S!vjq8>0T&#@Vn)`ZeQL1z++mZ ziE;hHNJ5IWIs7vrw!5=UI_Pk9%A?CA@8Z3#%eSi4@O98Zhs&?O>!9leS8}@v`ux&ChyRS6st4i9LK_t) zUZM3}Z2qJ3vr7Z*bP~iwpNfu0ZM(L%PRf7f_-}KCe_zf2n7*#Vze9c|TqM2fN}o4Z zo4ii=kB`%<4Ql>Nze^uS|4lm9)VoYy*Xf}1kN+5SLeM?^GU>~@9MR{c&OfRSy6Yr} z3z}Y`bgO9K*zT8UUM0m@UqX!a#~Tn=bLziT{#X}_?^HD7RHrEPzSR6U;S#q4w`cm7 zt!vxGNO53d&etz8BGmvEJRXH~C{av=Ut zS$~qMqGPmrxiK7KB+@2@;=`2Z$j|%rg7G%+sk#(q2hAHbcL=Lb*R{S zM+Y5rxcWfnlRD_2gAO|AaP>e%?S)!wuHP+tf2z5B$ym+)xJzA#1tt05C>xjpq+H-F za`?Ilg}x#W7$A5jTxTbVPiNmYV}W^gwVTumv2)0nqhYQ9cB|-#A8` z6{Q{&WW{)2cf7bVp)q12BpCj(B>sKkiNyS<>u$V5n)WT_!tTmW8%^Hy#F!^W^!eNf$I!c=?oQT=W>?^PV5s)m7%M?xmIG}Nk0rfqpR{oyFzxS=Kjft7z$Am)StOO(h7s+?q&PaM; z;Co4MCcST5RXdK+0k5lB&-D25=I;`tu1j1Y1;T9AY4(X=<{VCmSx3` zj&QX9NFy2-mS{LG6I7jJcV^L|rDLOF+qP|0Y&#X(wrv{~+qP}LaZ<6Jbk4bbdyM`A z`{UYcO+1s7j;UDE-hRp3X3VO8pps;>!otVJDyq|UX*D-J1JxmsGSPo8nA8Yv)OuYs z+iI3hMkAkJ>sw%Ac=5|riG8FiD-<{)?U|1U)A@yAmZPYkhVAk1!+gy(Ny&r(mm&~r zC`$BHUpaG+IAAUnTT^+u{9Fqv)BPm+NPB_!$*D=u0Cif1xArLBKWVF6idBXQ?&c9T z-aO(cxhR%i;TlAy80oN~!r*tRud(bK7HX~v&trx$kU+j!&{@)>GG_mQ;miP1?go5B@dRo*ip z#pzj=mX~*jIQqIA@?PVM1=!I7$(=@S<32jf=|&_}go?PM)U5KRvADh;Mem`e>y z$P|8U8n(l-)Gq?gf{*AcXcvP;Puuxio(AGz8Mt4`n8C$2iKI+bl8SNG+n)mm`;k+) zLp=6w;ytk)e(iwxddpmqTG0&+oSjwL$I8z(Pcj_{&Fs4}{hL5u0ICju=hEuAD>yj> zISMIx5;IAHh~6b@zBj$5amcW`_PIX1>+H*3cIgQNeAckCi9;d@+V6a+{iAFg^_a{~ z_LAy1(E@I^)e222j=x8Gr8ispGQ=F>J|1E@3z;hACI5U$mgm?zm(qNuFm?Q{llFQq zTlGQwKF-Pn*WcW3oZyL!wzp~9sy^ktuKDK_BMiGi(6R%*TBULz3CKeIY6|DDf54#E z&4@XjY|R?4b-%TAt!!9J7F$lnpr9i`jic*bZr?&T`SSl`wT9pWp2qs_p9BcT8ov!1 zn}n9{4|2%dO^v#OD!N^s1{P5+?rX$q+e8|D*1C1^Y%M_IJ2!M2wo?!p1{9U}=KVF( zrqj7TQ#-XJw1SO){CS>T63$Nabv*vg${*d)9klXhW*=T6Pv=&nyxj5mjz*+?sETLB z>$C@h^^=@+zIog9dEGp_<7{gn_p3&PtTVRvsHpLH6`PBfCvit)(SHwk)Ddiay$j*_ zkcH#~k1DV9Oa=9)hG$=SR^|jrU{h2M85g3Ah#F989+6C%x@Tv<&HoC>)s)KIG%Sz)p1uOb?>~8h`$>QqNIfBb>UDmb7@-?!>hR5&I;vu? z1}=votfaEAx6K?Evfv~0$^mE@4B>Viuj|f^8lhy%@v4@{L`%#h&QGhFbyJ&`HFUH- z8JC8Zhp0fKvWaitTuxqjUDbU#`uEnP`S#HRh%B_DU6D05FEoVSn*RcvBA9yAn+!1- ziggZeQR$dIOMGk5Lup{?)qC~nC7Dj`$z~DpoEgE!KY>`|ZoelWxu^FF)K&XqzM0=l z)s=ilCfsUS+n7dPU+h3xf@$8iVxagKR^A#5$5t&>Kep*APW?2~BnAGuMvRoyN1odt zmFekfes)(JK}F(^&}1{PmJ{}}jYtuwyh_g=r<%XG3Ep!)=DL5^{^#%eizc~!+@&Sf z_Nk=t{Bk3*aBD|;9RX5^1zBnwW;nuo96@3`XiZ(QG(xpDMSrMS>1Xq?$v4O-5>Ao4Z@T)+{K?Qt6KlrId6- zy;qay#itCr6|P7>>Ta0wwMKgT>mKRl5nGrb60x_KM8*8vB=@1V(?|kjGu|6gfn8af zHJk#N-iVY?>FMY6^k8S`YWV#Q3^Ke^n= zVdCF5(A-O&4OiK8tys2RkWP{T}dsX@V-G z*N#vp6<(?lhRghph+OH27#@UXGk+lz0iS$DO0fy3K*KIkM-Yky5T|#qFzgZG_zEpl z90nyGa|fmc&jS~!&A2K=C&KdVM6m{tegoPN!^q=$xTx4q@nn3C5l{Dz6{+{DB~kJ7 zx%mzX+d~)|;GM_9rGP+FvR#=~hJ7nt)VC|1Ix`&j zg8(E$4zM!PJlr$$z(A7*FzZa39@=Dxh-*%ma&|p%E4N^ZEvQA34uMEqaSx zH_Tva=l4m~^-7x2p!C{~2bUEdepUH(wSVVb+p&ctc4bE=gXb zrrpYaov~3j=1rB>hCX$PS)A<5{hWcM^)ubpIy{pKZv2*4%n5VGfmdz-+qL!ldY=gK^HXoy@=P)OOV!qTJJl@wF$cC9a*?CA z*N1Fjw(f%p_a$4pYM`--D-P{_*OULC%MAaGR|gX+xe4}tLY!WP2|aK9zc zNza5Jw1k-F#gWXRJ_Iz5HWd29gZw3KCDS$Jq#Py#%aMBC==@Lzg#`&+vKm#j>?&W) zl0IK3&I;$JHAaQH0hMhA7Tb?1Z8YP{dWxOqtewa<1FflPv#v1yMEy^~k8y-VNNmMJ z08fXVkgV`Q%_P^%B=DELcV*sC%y(2^#N0z6(PypEe5K zcA@v`809yOaeh+ulS}U*yiJAX;gwiMhQrKCHIO8Ve_0tJH1iF^Dz9tWDt-6o4Jf?z z?)3N^HD6i7{q3)nn%Nrvf;A0W=ib{-k|#ETmA^&Xo9ic2xuw^#8oH%%^7U`ITe+Uw zC<$oX;=qxD3E2btoVY_Ivp=D!0oi(d)7)vUMu_r~157bT+))7Tpdlt&p?8;jXj+vi zpR)D#&v{~ek5GsK!aA(P89NUarOZ0sFKfMl>Hew}v6m&u{JU`{yVGby-YG#g9(Oze zOk$sQrhzsfgtb7e8~7G&u_~%$6WwD}B0`SH0hbIk8x%Q&?wS8^mowrS_l))2-rFY6 z?>P81*%5voMks+4mQpC#iWr+yqPMsUS?f<8)iGf z8?=@zi7?UxFJsC@r-D(-tWmtw%f+N(Tl9Ro-e>54-k4}}JDtEhVZ;p=G%^(nR3B-L zhL0VtNe4OMjX(#XSoy_u8@fcXnbmU;MT>2(gN&97Njl1WVVXII7 zx0EWAe`RW!RsnEIqnX|+0r@0cIRfYVQ2^2sl*1R)h z=~I2*dDLtQxrDREDOa@dh8N4*GK+|Uoct9un^wb|cmoFA=Mn-sc7yBSU)%|-Vtc+{ZK+|d6kv;W`f z?3c0v|CJ}+i&^?F-#Q=283-kGea9M?^SoMGoA#;<&k}D9UN&%HLPrdVjZn|^|Gt5O zei-fU$Gopw>L;s9G}8wxBwRgl)KR#udChz1)@MLb=#P~;*@~J-HYSp!PquC)gcVwr z!_hGuc-Ix+?Rr`@)MfA|5s7~Rn>8$5`-rIU6ok5N8E>t$;+;Zo|5+|Np=X5JSKxr`N*~W4;US#O z>2Av+ZcHnAHqepyKY<0HHD1C0i@7Lu{oigbO4)f#Kc;J$XyXZtDOFmmhYpyRmepBokI{7b}UQgs|iriAcTP7 zr^~+NY}aaGFe$k`T#c8D(P2kk9Xi}rFXQ{@*egA7L{$3J0x#LXE4{!r%9!xI&7|Nu zi$EK$bXi%|W$d)`?svTSTYqSJas4-}*W0}gzpHV-?2)ps?HPVw*3uy!O5*`u4Ndi9 zVyqXe?0Q1De?2F;6zPmiwnC!k!_=6E1a_5XYKfu|5Z+H6tFymjuhs$&;gz_|`oJP_ zR5P>KK`7(<-^}iguZ-M0#6Vrd2q7G3nV#GQZr7~GCw%`=HAY1$)p#-Gd<{J+=S0`vaWpA8}!zS-fLr(tL>g3_Q zOh-If^H(gI+3@tEUIRK_qo1a+UeR2DF1;I&)I>6&6!DC-EPn^6SF5655qqK)1^B@W z);0OLewjLdV}3n4q8B4KehV=T*o;)$0MK#q-u!Bd?SxEFqxWjh7;=$o_A|{J|Hi_Y z()e>oo&?2)*LLPy>%n=5Vj#*H!6G8{xc<-N#uQ1>i zt#!-0We4=BtZ`@g(FTwHzz8Q4pL*0+hOTz5Q#foANLy8}_iV)=<_pWk!Ku0e+ZFE* z+<;B~9ZR_Ck{{V*3wgs%Gk%B7zp7O)i^}DUf`J98#9~?61|Dx$^*E`%BOGe?yMWqC z0C-Sx3e{#LOqyMFDliorG?bTc)B9~L^ph51&+BO#%4oW*8}$IjKYHe_Xo^RGf@LOs=BXg7llb zH%)`CP^>oJ)t6;*OyHNTWSAk1O%#p|#xI>WL{!#Njty`(rpi_v2%fW64<^UTXGq1! zH3A{QW?xw1P1Ak9Sv0f6H}G}LRI>I@R?^mVt$GBij;sW%;r`?*+o!6dCj2syn_NZE zR#CTMfiUD*Dt6TkDj5MRi-??l`xrh#QnyAa^^E+o?59Jd%Wq(tklw--``v%N3q(CQ zo_H=wCDHhMDR@E?DoV8Ki22rGYvcK8rpOafm_lSkGujv`w-_pwLgWr9R#C!`*=P>0 zwUpP#XnThvf$E>hZ)C6xRC5r-@$*e;ak?(+U_ZldzmfegQHY$6_(zIgqnM#1Qi-J^ z%qV(ArDy+=BP{oWT~-NNQYm_u$uGJMDQLx^qbZq*Gbxz+lVqN223#@Ff#`QZ}`EJYgq6{G`;4kf74mUnaA%p~Gs2ABjEaV91( zVGk#u7-fq=hwfGdjUr$oY8~cJ2bFXaE~1Lv(27vn@G8?k%m ztj6@&%mkadh4wFPzNn4SQ>~5f-y>}d#ZUlpe*`h1zo>zsX?ST_k^L#-*jTQ^$qt7a zUqJR@Hf}*ILlI&a*CStsG(q%(! zAGs756%!`8Ls!#_Y6a(*YA>#$V)sef-iMX#7Oo5JDCN zKTa27r>1W&_rv;JPyg)^qj~}%oMAd-LR_ROnaNat^U2^iGcT*C8a1GrE^by_l2i&* zk&rB)MT)rnVal!b6I||(uFZ)pLrZsIbVusNCs$c4ZEJ=wmNl0Lghu9}MqsjLs6Q9Y zGMK8H>(l$t?NMIM+{lB4$Xc%Q1$}#*41}_Eao_=*EJ$Eq$yCB%oS*Y<-4q1c$50fS zQL`=hci2wn^fZ#iRO9j2kVjq9&Tk!P{c3mX; z=tAgd+WU`+4&BU&A#@2}?ceCnbm@Y7=zdqUOD?Hl2BF9PHrJHKgqHQPJM}Ve8FrD% zVKMsNrn}nFdz)e)C^;YyStYnCx%H$XwiSLH9IYaCP$o#5276>owf(|eZKKXB$Ve~X z-Q+(PRM+&ix+2;UGhtd9zlN*O7|cz4!CuKUo_0hw%}lz=W&1Ow_DTuk4q!$UnPq@o z|J}-~vDtYN+GLh`SD18a(s9Tk;5(u$6*#Hk$++==x=Sa!_@N32FB4IXW-2ma2BY#I}gS2UU?$%m%Hmj81YpLC+EcCpGb**i5Q?Y!w0Nq|U z#xIH=9Ns(#2~95nJlQG4O08Jk>jJ4kbb6okxOMa-N@l<7hj?pbePAxQ zPYPbCS?S6lp|Z{7wZO;L+Qlrfd61KcYxX+A1RPfXWh-UxZ)^Lf006uV7G``xxwud( zM=zOt4S8>pRsS~Vdpn>HhNn#eI@M>SH3H8MvfarJ=ls|kGh)Wm!B)<5N2|1$B{ zdypnzuLUFd3n~%AQwH|Sv{jwa@RC~(nJTQ=*N)()VTk| zZyT<;H;^+qa^~4?jyTO5h7sobN`7H{{58_@k@L=4x^%@ z$NVwBMaQubr)Dj8aWk-`7#bHEQ^&}oZ!ooqR?@Ll94~aRL3gpvm?D!Sj-6cRXTBrX z8pQ%Z5>95XYhd7hEgQMId2c-iQUD+$Uma_Qz6{ zAPc*Xsv^LklS1#&Ta-O*qt&ODfFw)E0%;DjK$2D{SfdY8UIhM4aoxs}fWTA$%|XeS zcF++O7APzPmv93130ajT*7n~@7Zu~1Pe)5Ml-|IJ)+Md(0FjdU&|$k32x(2 zto$z`LDHwK*OjOCrbf%SCh(wSU;(F|!Jf?>@M9p;)O3-+Y4hrK=~T$>a!*o{_CQzCK_t1#%xW|nvkt92Es1vWo>NSjRcf9VNf7jF z?q`v-ikPGFHqy{bLJg8c_t!`2nA^IvL6xX<^iTrrqi)y}pEj=BNQt1>su%eK@YSHO zBp4_A!}qZ4^epz%{GCAK7lyE^{{d#UF?6O06F#B>8fUSEWs7KRC`sj})8Szgm!zY- zaaR>gsHV!={rSY(N4KAi0J&MnuaW~^o5@Bm)U^0jP0F^xvqZZc*BUXM z9cq$a#kFC@KWr$PvNnR;s#bF6%eVdpds=CCebabCd=CP@cDZT?OCjZO5kLsR??X%RqABuf|Jd?an%p>}TW{kP? zn@|p->A1{^->vFu{GE9;8fD}#SVkdd8;fiw1tIsny;}C?)aRnC;K9KWz{{h4B#c-F zX2v+Vc+NQna<+A*t=*T{8m~^;tB#@5`o4QZtK(UL=6bJ6{rUH%fSVU*q!f(Aec^z8 zx}dRoqmj}HOedRW_A>Q-b?4RfA}bhd^!?$H%olFjq7``USdI?8;R29YykF=1or%;5 zQLlv)i>{29=vMA%1OCfl*5?Rsog9Z6bc-BUM3Snaf++YOgx|aKN2whQWtJQpq24it z9Qr3R99FN_&BUAiI$l`4oyyuJIIP0JZOt{&==nQ6Oo z(XR6#@Y8cAGF#`vn#UvVz9X)_ zF6aDaRdT2PT`;Dsc~0)9RWxg1--snjR(&{4&OjMSNXbhCc!|RL)VFb9#nW!3io{!s@Xf3z_b{B{F z8N4ZJxL9mH{9jpTAGKDTmCr9Ic=Yid&6#wk*f7cAAc(wm-~yfXubh^trTHgS1sLO28l<;MYXV&z*4J5>Qz^fKv}vP&Mm zB_-f8#JCLIU+T%upsF)njsqfX-;Xrys1#eSVjH!U@P$Vye^1ANOBi zW@yOt3Ql#5f*%a=iQzGJkqe&sEQ-%v3lQ|;Xh?QwMUy)jrQNAU))p{_2qDy=^K}|# zV2KVRo>A_)GE}cG>PEdlqOJ^tWFxyTDUoAu(@CMD{q?)7oCbUSauX7@#8+7E4(>WN zZ$HwcD;EJnnhSgR#}0F3QC*}coWqQ$@Lo7NzJERESZ}P~_0;;)IZD5=CV0?<_Hoaa zd4{1=4-9XYcs8h318zX?^wg&HU4I~|K<;Ik<}kc>if{*fcaIG`hwQG2e;wIPvu_dk zi!h9`AF_i=((ZWL&PqP^Z@JmDWa#)R9ed=2_0+q+lII)t zI8Q*k#gkhC#aZ0r?w2IlYpl5@?dawYanzAh%xD>ZczObNfc8^Io({*bW^;zPclQmBDU#T3P$heznC zAGP|BEexIYXk=wq?W82&n)&v_lp}wsy)MH0IHPj^vf%js*yeamW2uuf?^q$Y#gD83 znqL1jtk5b$by(!rFo4mOZ#$CMh_&CuI_p>mT}FIHS-zgQdZ9RiS?=VTnuNuSo17e_ z`8CpoLV!!4aNnj?wq^Cnd83*Rww>t~j;8e8n*w`NBM9pbq(J!1nufA>2#c7MvZgLA~SI_EngROj4#{ zpbQQZLNJA=@(!E7kXvnfq}|84&0#2_%GR+CI+0E*pke?p&TyvpPk0MqlJ?BeS-$h+ zO5HMr!*=`TXkWoY@Wpy?bvPt$Lerfdl)W^PC|I|Xb;z(BoSBIi?85-&D->sTS6y== zqgI)O_Pitp*;V^>=y$y`Nk~EOGAmImrx;nNn%7|Mfi&gOu~E3P_ry|*%q}96n>}1y zM_Cnub@d?gF*V#(o^9FQTHa!YTeX@Z>as6|T5+KPm?ts26QL+QDI9NQ0nHz|kJp7K zCuG*J9I>F&x5Om(#ggD{!M|587c#1f16C{$f5S8~2PT`tU`QgQakVw@ZcogZT^6?Z zCf(ZlgqH=!*o!KXp~4l3nW;dYoWc7=OV6~+6*H>S=-3^oMlbrA(ed~mFJ?O8TuS}g z6*{fsn1TKQI&Ob=UXSgThedkJT}5-|zwT;cbhdtTn96cKH6;JNX_BlXW{_g^nFw6y z%cM8OldgEZEiEy(;)~pe&Lq-^?T5;SzUgZfC-I?ei1cgx*Td;GAKFOdP=g~HA1tRpGPX_z;Hc0t4l@(Y%Nb!KLfK<~&Rb08MMK_0BocKs$_r8DWe%3_&?)vk9Pi(JSVualg;$^}at^x%TJY z8X^2=&l%)#-pJz!iGH}wx7%Z=&w$^~0UpbF4`1lFQHR-KCH5@d<)%hrP1CdjeDMO3 zXjaum^zuyEOh?Gp`xjogW#q!y_Q3C-KDbYs;oTp!fIAXgyboPUg4(1oAqH;ML8X85 zJ~bsyO}9Mx>wENzsRKaMR_m4AO5wdt*BBPBNLrRboO#;KypQCEzRgW^wkl z742hBs8aUOHq>0yR`H>mm9qvXafIY&OU1)v!<({Mpi8_69=C6UPjTxNjtWjHD%z#* zN?mtnDhU$t`l)mZm=aJd*!nIX#*xT#Y??x`YLomjv2oSHH6lwj!HbwO&{Q}@t+kcg zc-(C6+q8?})LmIl;jYVK$M)HuO=&*muA~sk!&a?oN6+rW-#v(}o_C!vzEZ#>G~0dG zj<}Dnr+-}SSbr`Yyy(UvvQSbqH8f2fkpALI?f37G0y%5KCmD_T^cXgbl;Uhb;2c$457+I;PoY2Xtw(rLu+}DZ*3~~&ybPNY~ z=C%MsU!iuWy38pW)W$H@FSmR?YN<^zFT~br?3=t7E1t_SVnL=*p2ZZVfht%a7^VrE zGi7CPXI@r{SeMOWb)rsKUlY!<`^kV=MF znKpgF$fY_bBe)5Ipr?6Yg&w+OJMbfUA<=(-{<{F-e2#j!Da5f zXPzpE`*6ZQH)5T|y1mi@C1lIE+fsj>obnvHgCi=ZB!yO{8j@tFm{b*%#*r?t+o-U; z$qn1ha;S`Jm6VN8TM+N%zfa}Ng)Bh8Kj>8l3hHOve4`dHJ~#An+jcnBqz}xXCTzTu zLQ_sZjFXr%pb1C8lxiZCp8goDw8myBFXH}g`(t5k_EfL5hD^a54}>8GO}LM|6S^lD4+&+gy#?GG>CXYLFRH zg=<{C45kZxAY=@)S7VoDpdI{#g`>5{fH=k5!&MLhx zF8eDz9TiSX{jU{v)6lqAYSSI(nUP1j{++?!Gkb=ZIclg5nd+6O#ELU<30kv(_m2+F zKBi|k6@G7IdTo*IuKV)+(w-4}D;}WI*6-hgANN_GjowTx<86=ow5&NgOsW~{xqIiQ;@DTRzgKaxVoN|WBeRXSNo{pO#k0?|h- zIcF8IGc1w#{lcC3=V|NiW+}#8lR4;T&!!Pq!iaYo6{ulL(RK-MJ!=e1nLrLH0^XBr$y?u&9sGQkgLz@?K){59;z~!}>&Jh+kB*FmwLL0_bEJZX-%j}k_D;&oudp$y^%n|zt zl|3e&Omr%8XC^!3SZ_0HOy&Y|eSA}gm1b`3z0_9svWBrq;+%C?e#PRV2XP0hZ6OWHXF z?iwm!dK9`5yL^MQgVw=Y?GJPg3a;`kYEk=E%H@=-dh0szGmpW4r+z9z4B&oAP9s0yEec~C4vGio5;jF@`R*- zl#T`)P{)&Mh2L_TLEv_L3MD|6sQ7bY*+=@XdKTK^x!!*xqmWlw#-m-KogGmI2_WY9 z74I){Twc2zD;FZkkXdx%reSKkUMm{VP zm9zFM;SNSLNdl;&X~_>YVp*Ph*8cQQlmX$q3&q1qB$n8?YC5=IKXV7K?~00cQ<38U2!^)DH852riWDc0}1~9ZV zm7#0?a}OPJ*=m;n#LF)*ul_yKp#Yxr+&N6Q*vVYG=e1E97yNJI{Okvrt=)QM2e=xL zaCGo$&zxBOZ5kE3Wz2tSP^6*lwiTff1oa-B8(ei#$I*Fj4;Kx{Ta5;%?yPN;R9*R= zcB`m+7i%xwLo3vjh|$4vdWhl7U$u}f`At&p`!jmCn$fNGL$|ecH zrrD$WpUOc*?mg~i*Ua);DII>p=lAjvQW+zdi(S=j zdaK@@t6dZ1zkgle*UG7`@_Naf?`T0q zy5*I<^^||Rn>Hxf#PGem60O8y`Tzh9@woRZ_);d^g<P>$ULgIc9 zosorBUNZW(G4ae9bUKCQB_?`7#+@jb*JSd-7S}lF;+Ao zBf`m<|Jn_@O;LJ6bmqs;2;xe~<=3Mkt1lDS$O3MN1DreyE4=#ri<5p<8Zp&A?S1kF z^lq`ACIMf$o+@E>Jd@Hel_qLflLK4UJyr&44ODN#3#icaA?>|Y(#)gpGOCu^6ilLU zT`@IsAkbu_)pjX`SGv{Lvgk2+`apyn0}2QQbKt~eF^EJNL$$tlee`aawy#H8)XGcx zpWM0c5g*-^KuuaG?x;XgmcTxDJM3halg*~fhGtvhbTSPcy+u@AUKT9$bp6dY+2g)_ zSaRb!cBQVVJIvaJz(9w*<-E70Di5g=)xT0=hsrKHm9$n)0qg4>XQy-oAzh9Ds9L3* zDF;p*d!`RyM=5&d-jr9RnOOCJ7-h3xV*kN9*b?cVmFUEleGSA&d|Nc!3=>awWhz7& zjvV`*zKV8t!%0^X%cY{wycBDqaD~TZ`L$mjPjzbo5*fma_7l^*D})!AM<*Npj>SUm zBDFr*lb(8RL*JVfv? zH7@QsaNXabsuPgutLW$z-oDm(S~V!Wj{+m?K87;==GC+HwS!v`@U@WK4|77MO60AT zEQEVzZ|ABwMLX8hfBgI?lPeJBh)?cgW)`1JrtB-giM5z12e8(arW}VsAbJM*<%lao zT}nqay5Lt!8l$Om2qBvcs{xc$hDlh6{DrZvjtYoPu{u{Y%0V+ z745gyqYbVSBIn-?4HM9X6H&C{gKxdF>`<*W%Vq~)Pm;UFKp5wt1`tw_sHkfF;1MTp z0=*}l&vy8k8CgFiWWp|FhOrsav%#ZD2H0{6Ki%%Tt;K3v4&e2w=5aK3l+H5$9 zWZEj~DyG6Ktq!|y#3KkB-Gr&SVA(`|TV)$ozt##29bTSWLPj=5V!;GHTL!o~9wEqf zKgdh@fdU~9h^{vuQ@B?9xF1L3G=H4l1ha?4LepO}gr%{5dcExEZ*A*Z2quv_r2AoW z&~hU$Hy>{+Z=FnCVnZevniIptK*YCImvx4*-rVI>s_T{>*N+@-?WOJa5j9{W56r># z&!N}$xR{mh*wyad0NtQ>)q7wDe>vI*&FD?gdtAs#FqkTBFE+9pa^ObShNd&F*~%l}oQ=__hsOqQ>Jhen-DB%A>`hb}qO@@zMf=^B znB3JYd1jl_ZgY~S-gA(1<65bn0 z2mC4x!@?WAySK%&m&_{u3r~~KDTLG8XIw9*g@L(K?eBs>NFTjZQT;5r<)s zVdMI%^5$xu7KDn03}#)Ly>&DSNSSoukOBxJWXt#@f5m6Z$?BW9!rF~m|Bv_IA_fQL zj_98|c>p1%@lyIaIg5~ea1G`L*ob~eYVe|QyE+{vsVMnW zWR zAtd482Kl1ZWh)?Gzcu2IUw(PO0%G-}&fL9ZH-8`KWe*3s>o zf+810bWL^}_gR4$d?8-zs~!WRq8%?S;fH+DM!pbmkI3n(_&XTWVH;(YTt)YQBFSh= zV+!asODCaeFi~BJsa+^U)$P}y8JJSilrjg1G!VY@6Y`L&xN-X_@8=?csZ#8)z4ypI zRUJaf2t&r-v(KuISi{ouN-T`07umOp)DnohaT#$wcjA>&xBepA>bz58w~?f&icHvL z8kxs{Hd2b#k@phDzS&34gX@`>Mg|t&`&oui{=X3LoVe2XvBNH)$=|<>WK%_6*A;p| zlY43SoqcJOuVIdGgkD1xz9@&-df<*uL|$(dc0i9V6?(LB)1wZK6+LFAdnbwTygiEW z0hkdq)DcCv-m+Lhg^CnY68~m=eL~^S%rQvJu}@566Q~-_uKJT^yA){H@CUS%*M8VS z9;+h+VOPDVW};r2zob;vOf%!{)Ag1YEhz{%h^gO~ySj%feeho~w(RTVYzYOn9(qhPL zUIQf@)<~028!`rnKed66;YhMp6 z#!vXSa2!jhiix3`gy+&}3)MFISyj-W(H*DXI}!5WIX0kVkTA(%BB>#X#Zs??D=pjO z>kng~-9kvli!6T7DiF#V&}8GCTKP>o_<(B#O8h@#b+o#zgx586k~*Xg*~VCb58}U! zZvD%(i^sdzN$U6pl_p*N)CcEB%=I|(47!EJi+TG?+_xhsQTV!Z660GN9>>4*kbnTz zED|r7{E4f@PR2g3TEeG_8y9dfx>%`YwjY-VkeMLA@$rWEkYkP6JG~4Hg#s3j6c6R- z(-_OGaue;|Jl{9n_#KrY+O#1N&V;OAgl+CY4gY=3Nh%BEU#iu4zsvo`#-M7J9KP=|~L!UzRV$m^y5W>`R$cfh5(VNT^Q z^xa&SiEsw+7MXHc_@F))){xy#?JOa_z6DgtMUWtiOVh@b2ao;Q4+I7Ma;@Sr2iqjR zIasJQYja_*JBwtx?MA#nnRxBM?Po&JX33gR@PdGK(_eD!eVmR}+hw|TB< zM&g{+^aJr9vF#w4bxOrz6|sIWMd_EzgC^HAVF+4Sf(0Vxt639sGpvor!+~QO!R;cH zz~yS`WYK!K$}!yM_suwt4?rx|_^gFK5dQNd_g5O2TyQ?Vbs~WvRr+j^7B^n$M7Uyb z?V184&PxMC8!$w8E0iJwt>SNKi6uy;eUT;sIrCS70-59!lA+YIxrA5K>K<~1$G&mI z2}l#Kp?h-)e#i3<#HTj?aG6reQouE6M`jA9-n(Ip@={we2fhH5D1~WNoQ+D0=N_;B zAoe?(qLa|0t>?|Rn`QV@w|LJ#E7&v0nCbR4=9l-rC@sNPuuFal zGxaYwJC#-b9eWmL=2DTe}!KC6@8@1JlNLKqqk-Lsa{qKis9KEggkovkr&Bye@2V8I|Q)_u)@Mj(+ zNy?MENgU)~R22d#CHf9%y!=NoehJ6M3S6h9RO|vw;X-gm_Oc@5jS}O=Y4dXn%x8yl zvU#!9LCBMexHFD${YGH&%)r9!w|TFTpA{(orsg-8>+|kwT*V+{8WTZhaQkubG1{^Z z&?GR1_tfZVzS+Ew&iiMCDyTlGpJ{GP;IL?xrRuv3gssPFE!zh7d-a64sn}WTACZF2 zZNH+hGTBop<{2s1`SYuf|qfIjFZ8Ms%X2Q#;Mt5JA-N;pjZFQus}3Q zy%Wi-e+2CVcsoFR8VNpLVoEJ?GKgGd$Hx_6#cH z7h`C@6mBj5YU0QB%ag^8jjXCDwyYfIOdQGxU24fJ-`hoEXu!P|??3j=&aB0wZeaC0 zv@pn)rk6jWrTW<6e8ptfEz|nj+9uS$REXl0u`)@S&Kige>g=(lBEG2L09>&un?KTNcPs`h1M#ZIc z=ShCA9tVtqzWA`xzV6v(CVCGeV@4>v1iGhrCrqYd0<*sJ*v-D)@?ewkmu~5pXQYNG1xjC$z6M~>=FPq7EoZ*`#M?nr+0^L*py#jwS*`S;HvpOg9?dpXd zLx9Fj$Rpo?8G6fH`B%CbXO`5v_e6h^68m;(nCnJ)-+4A*^qKRmQX&9nUMm0%qxbPWn;? zA#&sWaB@#LdP*PSwuslSLL|6Z$#l{&QF@vOrD0VOy}B+F}N(m8W#88)T{f zVD%3N-2zyH5|$1DM%o1~XMy7KOtO*ePyKqVc=9+CUjChkVYgH7% zIEbAC!E@fm<=fp#Cs)2AUv^5;Pwkq}Z_DF!`_yKLNPfv~NP4H`yHm^SHd__a+Ku2OjujM{78w$?1Js0410s*!>}{5LH|;-s&ogND znZj`jXDNzi2!am0+4_RiL?1{ojcj?R>fNq4jv@s?G(pi6%@Z_%5d;}vZ8YFDUz0Z@ z7EP z|5(JarQ%U1*J64pW9P*!ppCZty90S|(PX zVXJuvtnB2tVAO>rXq@LsNg+6S*C@e_4OmolB+-sc{2IKZ-;l7fG6AFxWVuQAV?%Y2Y5Y)e0Wd8Wmh$TsgmgrJx2R-_e75 z5zcoFo$VOr)?2CuGJPaL`HY|XDxN-0xiC-hT0bpoay&on&YMhtO>AO_L3u!Y zYzSfygBU>2KSmfT6;y%JZ~^8Q5+P|B3}ux{qO1@rO4@0vB<+Yn3}O(27(^F}&zARC zK7Yy4@z!JDeEYX4*!flxF`OqQ3L`Kv`|r05cbtA9erP$h?THE+gLOK}qn&iVPq|9w z8tm2Ja*Ts!I$AsmuL(N9RmE+=Bg+_iLF3;eE}_9$=-xLf@ZCFI~NG zd2l=6`XenLv`epCxE+z!W6sdU3t1%q|QYa?QutLoqh40`fqP;UJQ+ut@yW3+K`@S~$zYo6$-#x<5$CPnHj)}xV?`Orl zzzoY@Z^bXm-9@7L4dA((vRzgY9iZge-5%E@n@f=jU2gk$B}Z|{c1JGEi2PO0zcRRT zlVPT1w3Iz!NObQVbTL5Ad~?Zh+FjnjW$w z{5^dZHw{qmU{-1Msfs*tiq8|_RX5l2V3KV9uxun~Ey?J4_~_c={Jw=%agT%hQ26(r$LnOP2yfX%0yEOaAt@zg??UMMB5YPa)(1$(y@$s zxK%32CRe|L>PZaqy;sXwzqw91l?(Hx#weMkIHSb8==~pO3XdLD6ohMW0tE*sa=G3T zacDv@x#eZB4#qhp%Jgm^l;2gxbqQG6bOb(^6)Fq8fZ0wfr*Z)}%2?iwP(D9O z?F95Ct&-q@wSo@EVA%t63BbKowBl}es688_RPF_1aD1%j%YlW6{WeKw9wUxEs$&Z_ z0C9-8Rfk{DgPaHvre%she-HTnt=b0vBgF7S4*rYspd9#p3QEEI;5`baQ>Nh0Q9{)B zbT$ldep#o(uz+&Fxr2i0eNOwoG2;742>t@Vbc9WPg3bZ}!sHiq=5b1V=y@tFfawI6 zscTLCB9X@pq0eb2lcLj())CU%E#cB#V{rO}s^=N)y|0aBqYruj@NhGPH_R2%+^Q8J zJ%#(R8hQ`(3)LSOZQj$?Z#UHXjq{(U>@AcsQ&Y_>bALiX76QOWp zi>Y+wq7?WZw+vt1=tx!8%o`HD@JFj-;v+eQ;qD|*Cx~yVxiTrbyQdL#uC&}Ub#?EBdqaB0!5LhnBv}$ff`&cg%xHibyH%Fd zqin3IqIH&)H(JH=Y+P2ab;IYf5Me^~TTH zB1PC-irbSTNMr4e+)lDk;89%N>>l_28p6s8E1MbHUEw{e)m0v7rm{h+FugMw4KG_B z%iQqYO)cAKPb?;Qp$0lIz3hpw&*kXoKAmy*=o>~Zuln8K1Q01ZT~jic{Dps7w0~$C zrsM7m-aha>>P+{M7`lI1P@Lqx+GTNu<|cKD=6Z?IE<@Xl)A9xW-~CW4bUjbtzI14O z==YDC{8JeI*2z~^c+-U5cl{myZ?K#kn0o1+Gk~m*3byZ3HoLp8Q&w)vbBaP<&wZUA zY`Q7A3P4r@O3NzHG8(p9jwYtL&%A;5gvK)xBjO~_@xweBz;m>H&0L!&`XWXz3npJLrb+!qQgLlpCV$Img)hbh+!oUe~8 zbIx`C>Cc3ELC~XU`{yY}kZ4S#WL5rb!7{!i*JRgpD?ZZZZ%lRnd|;KkEZe^Le93Jx z;FsnG+s+xn=QkxsbGMq8H>j|{=RGCmru&DbEc!aJZ3;9}lnob|*-CKXY9mK(HiJgy9ISQi$g6473 zk=%BD*C*S=gH5}whM%u$`4kA35+SZ2`iu7$3;E~XXB)p%Kkyh|q7NLa$Rr`t3PuX> zIsO#V4ecq*O-BYcnf(?xTxTMrk%ewWwy_c;5E91lGA}G+r*C+(+0b;92=R+3Yb