鉴定改版：风扇数、供电口、丝印、序列号四项真伪依据在前，假卡依据各自独立（平均 1.5 项）；指南去档次、去卖家说法

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-04 19:40:50 +08:00
1 parent a8d7bc3427
commit f40436b7d2
@@ -5,6 +5,7 @@
 ### 第九阶段：剧情与收尾

 - 多语言第二轮审校（Claude 子代理逐语言通读 UI 与 16 章手册，交叉复审 Gemini 的修订）：采用 de 39、fr 56、es 34、pl 37、ru 45、ja 142 条（ja 里约一半是全角标点、×、〜 等机械统一）。要点：天数不再缩写、Tumbler 称谓与 Key-Drive 统一、手册页签名对齐界面、ASIC 时代统一、修正数处误译（俄语手册首章“卖出”写成用交易币付款、永续/挖矿章、日语质押章“向池子付款”等）。
+- 真伪依据改版：检视面板最前面四行是风扇数、供电口、背面丝印、序列号，四项全部符合标称型号才是正品，任何一项不符即为假冒；其后是型号和四项成色。风扇数、供电口各自独立（假卡不再固定两项都对不上），假卡四项各自露出破绽，至少一项，平均约 1.5 项（`Tuning.FakeSignChance`）。去掉检视面板和指南里的“卖家的说法”，该机制只在后台生效。指南里不再用“档次”，改称型号；背面图上画出序列号。
 - 检视面板的型号行右侧显示“标签价”（当前报价，随指出和改标签实时变化），鉴定客户的估价框同步。
 - 显卡鉴定指南的鉴定示例由 1 个增至 5 个（成色很差、假冒、轻微使用、全新），共 13 页。
 - 二手贩子的卡按卖家调整健康度：老实人 72–97、中间商 55–85、骗子 42–72，平均每张卡成色有问题的项（叶片、金手指、挡板、封条，共 4 项）约 0.5 / 1.5 / 2.5（原来三者都是 25–85，约 2.4）。范围进 `Tuning.UsedHealthMin/Max`。
@@ -136,9 +136,10 @@ def fan(c, cx, cy, accent, accent_dark, R=None):
        c.put(sx, sy, 'g')


-def gpu_front(accent, accent_dark, brand_text, tier=1, burnt=False):
+def gpu_front(accent, accent_dark, brand_text, tier=1, burnt=False, count=None, pin=None):
    """tier 决定实物特征：风扇数（1/2/3/3）与供电口（6 针 / 8 针 / 8 针 / 双 8 针）。"""
-    count = (1, 2, 3, 3)[tier]
+    count = count or (1, 2, 3, 3)[tier]
+    pin = (0, 1, 1, 2)[tier] if pin is None else pin
    fans, R = FAN_LAYOUT[count]
    c = Canvas(BW, BH)
    bracket(c)
@@ -180,7 +181,7 @@ def gpu_front(accent, accent_dark, brand_text, tier=1, burnt=False):
        c.rect(x, 7, x + 6, y0 - 1, 'p'); c.rect(x, 7, x + 1, y0 - 1, 'h' if i == 0 else 'p')
        c.rect(x + 5, 7, x + 6, y0 - 1, 'q'); c.rect(x, 7, x + 6, 7, 'q')
    # 供电口：低端 6 针；中端、高端 8 针；旗舰两个 8 针
-    for left, pins in ((((118, 6),) if tier == 0 else ((112, 8),) if tier < 3 else ((78, 8), (126, 8)))):
+    for left, pins in ((((118, 6),) if pin == 0 else ((112, 8),) if pin == 1 else ((78, 8), (126, 8)))):
        right = left + pins * 5 + 2
        c.rect(left, 5, right, y0 - 1, 'n'); c.rect(left, 5, right, 6, 'z')
        for i in range(pins):
@@ -416,6 +417,9 @@ BIG = {}
 for _b, (_a, _ad, _t) in {'probidia': ('G', 'g2', 'PROBIDIA'), 'pmd': ('R', 'r2', 'PMD')}.items():
    for _tier in range(4):
        BIG['gpu_big_%s_f_t%d' % (_b, _tier)] = (lambda a=_a, ad=_ad, t=_t, k=_tier: gpu_front(a, ad, t, k))
+    for _pin in range(3):                                      # 供电口与风扇数各自独立（假卡可以只对不上其中一项）
+        for _n in range(1, 4):
+            BIG['gpu_big_%s_f_p%dn%d' % (_b, _pin, _n)] = (lambda a=_a, ad=_ad, t=_t, p=_pin, n=_n: gpu_front(a, ad, t, 1, count=n, pin=p))
    BIG['gpu_big_%s_b' % _b] = (lambda a=_a, ad=_ad: gpu_back(a, ad))
 BIG['gpu_big_burnt_f'] = lambda: gpu_front('e', 'c', 'PROBIDIA', 1, burnt=True)
 BIG['gpu_big_burnt_b'] = lambda: gpu_back('e', 'c', burnt=True)
@@ -176,7 +176,7 @@ def fan(c, cx, cy, accent, burnt=False, R=7):
 FAN_LAYOUT_SMALL = {1: ([(26, 13)], 9), 2: ([(17, 13), (34, 13)], 7), 3: ([(14, 13), (26, 13), (38, 13)], 5)}


-def gpu_front(accent, accent_dark, burnt=False, tier=1):
+def gpu_front(accent, accent_dark, burnt=False, tier=1, count=None, pin=None):
    """显卡正面（48×32，3×2 格），略微俯视：石墨色散热罩带斜切角与品牌色斜条，两个七叶风扇，
    右端露出鳍片，顶沿露出铜热管和 8 针供电口，前沿是带元件的 PCB 和逐根画出的金手指。每格中心都不透明。"""
    c = Canvas(W, H)
@@ -194,7 +194,8 @@ def gpu_front(accent, accent_dark, burnt=False, tier=1):
        for y in range(TOP0 + 2, TOP1):
            c.put(x, y, 'g' if (x - (R - 4)) % 2 == 0 else 'k')
    c.rect(R - 5, TOP0 + 2, R - 5, TOP1 - 1, 'x')
-    count = (1, 2, 3, 3)[tier]
+    count = count or (1, 2, 3, 3)[tier]
+    pin = (0, 1, 1, 2)[tier] if pin is None else pin
    fans, fr = FAN_LAYOUT_SMALL[count]
    # 风扇之间的筋条
    for a, b in zip(fans, fans[1:]):
@@ -214,7 +215,7 @@ def gpu_front(accent, accent_dark, burnt=False, tier=1):
    for x0 in (L + 6, L + 8, L + 10, L + 12):
        c.put(x0, TOP0 - 1, 'p'); c.put(x0 + 1, TOP0 - 1, 'q')
    # 供电口：低端 6 针；中端、高端 8 针；旗舰两个 8 针（每针占两像素）
-    for left, pins in (((L + 22, 6),) if tier == 0 else ((L + 18, 8),) if tier < 3 else ((L + 8, 8), (L + 25, 8))):
+    for left, pins in (((L + 22, 6),) if pin == 0 else ((L + 18, 8),) if pin == 1 else ((L + 8, 8), (L + 25, 8))):
        for x in range(left, left + pins * 2):
            c.put(x, TOP0 - 1, 'n')
        for x in range(left, left + pins * 2, 2):
@@ -681,6 +682,10 @@ SPRITES = {
 for _tier in range(4):
    SPRITES['gpu_probidia_f_t%d' % _tier] = (lambda t=_tier: gpu_front('G', 'g2', tier=t))
    SPRITES['gpu_pmd_f_t%d' % _tier] = (lambda t=_tier: gpu_front('R', 'r2', tier=t))
+for _pin in range(3):
+    for _n in range(1, 4):
+        SPRITES['gpu_probidia_f_p%dn%d' % (_pin, _n)] = (lambda p=_pin, n=_n: gpu_front('G', 'g2', pin=p, count=n))
+        SPRITES['gpu_pmd_f_p%dn%d' % (_pin, _n)] = (lambda p=_pin, n=_n: gpu_front('R', 'r2', pin=p, count=n))

 def hw_button(symbol):
    """硬件钱包的物理按键（24×24）：石墨外圈、左上受光的金属环，中间凹下去的按键面，刻着 ✓ 或 ✕。"""
@@ -8,10 +8,14 @@ namespace Decentralized.Domain
    {
        public string Model;
        public int Fan, Fingers, Bracket, Print, Sticker, Serial;
+        /// <summary>风扇数、供电口：0 表示由型号的档次决定（说法里写的型号该有的），否则是写明的值（风扇数 1 到 3；供电口 1 到 3，对应 0 到 2 加一）。</summary>
+        public int CountSet, PinSet;

        public int Tier => Hardware.Specs[Model].Tier;
+        public int Count => CountSet != 0 ? CountSet : Hardware.FanCount[Tier];
+        public int Pin => PinSet != 0 ? PinSet - 1 : Hardware.PinClass[Tier];

-        public int Get(int row) => row == CardLabels.RowBuild ? Tier : row == CardLabels.RowFan ? Fan : row == CardLabels.RowFingers ? Fingers
+        public int Get(int row) => row == CardLabels.RowCount ? Count : row == CardLabels.RowPin ? Pin : row == CardLabels.RowFan ? Fan : row == CardLabels.RowFingers ? Fingers
            : row == CardLabels.RowBracket ? Bracket : row == CardLabels.RowPrint ? Print : row == CardLabels.RowSerial ? Serial : Sticker;

        public Claim With(int row, int value)
@@ -20,24 +24,26 @@ namespace Decentralized.Domain
            if (row == CardLabels.RowFan) c.Fan = value; else if (row == CardLabels.RowFingers) c.Fingers = value;
            else if (row == CardLabels.RowBracket) c.Bracket = value; else if (row == CardLabels.RowPrint) c.Print = value;
            else if (row == CardLabels.RowSerial) c.Serial = value; else if (row == CardLabels.RowSeal) c.Sticker = value;
+            else if (row == CardLabels.RowCount) c.CountSet = value; else if (row == CardLabels.RowPin) c.PinSet = value + 1;
            return c;
        }

-        public string Encode() => $"{Model}:{Fan}{Fingers}{Bracket}{Print}{Sticker}{Serial}";
+        public string Encode() => $"{Model}:{Fan}{Fingers}{Bracket}{Print}{Sticker}{Serial}{CountSet}{PinSet}";

        public static Claim Decode(string s)
        {
            var p = (s ?? "").Split(':');
-            if (p.Length != 2 || p[1].Length != 6 || !Hardware.Specs.ContainsKey(p[0])) return default;
+            if (p.Length != 2 || (p[1].Length != 6 && p[1].Length != 8) || !Hardware.Specs.ContainsKey(p[0])) return default;
            int D(int i) => Math.Max(0, Math.Min(2, p[1][i] - '0'));
-            return new Claim { Model = p[0], Fan = D(0), Fingers = D(1), Bracket = D(2), Print = D(3), Sticker = D(4), Serial = D(5) };
+            int E(int i) => p[1].Length > i ? Math.Max(0, Math.Min(3, p[1][i] - '0')) : 0;
+            return new Claim { Model = p[0], Fan = D(0), Fingers = D(1), Bracket = D(2), Print = D(3), Sticker = D(4), Serial = D(5), CountSet = E(6), PinSet = E(7) };
        }

        /// <summary>按真实情况写出的说法（没有隐瞒）。</summary>
        public static Claim Truth(Unit u)
        {
            var l = u.Appearance;
-            return new Claim { Model = u.FakeOf ?? u.Model, Fan = l.Fan, Fingers = l.Fingers, Bracket = l.Bracket, Print = l.Print, Sticker = l.Sticker, Serial = l.Serial };
+            return new Claim { Model = u.FakeOf ?? u.Model, Fan = l.Fan, Fingers = l.Fingers, Bracket = l.Bracket, Print = l.Print, Sticker = l.Sticker, Serial = l.Serial, CountSet = u.ObservedCount, PinSet = u.ObservedPin + 1 };
        }
    }

@@ -49,10 +55,12 @@ namespace Decentralized.Domain
    /// </summary>
    public static class CardLabels
    {
-        public const int RowSpec = 1, RowBuild = 2, RowFan = 4, RowFingers = 8, RowBracket = 16, RowPrint = 32, RowSerial = 64, RowSeal = 128, AllRows = 255;
-        /// <summary>标签栏的顺序：第一行鉴定真伪（型号；依据是供电口与风扇数、序列号、背面丝印，玩家对着大图自己看），后四行鉴定成色。</summary>
-        public static readonly int[] Rows = { RowSpec, RowFan, RowFingers, RowBracket, RowSeal };
-        public const int AuthRows = 1;
+        public const int RowSpec = 1, RowCount = 2, RowFan = 4, RowFingers = 8, RowBracket = 16, RowPrint = 32, RowSerial = 64, RowSeal = 128, RowPin = 256, AllRows = 511;
+        /// <summary>标签栏的顺序：风扇数、供电口、背面丝印、序列号（真伪依据），型号，叶片、金手指、挡板、封条（成色）。</summary>
+        public static readonly int[] Rows = { RowCount, RowPin, RowPrint, RowSerial, RowSpec, RowFan, RowFingers, RowBracket, RowSeal };
+        /// <summary>前四行是真伪依据（风扇数、供电口、背面丝印、序列号），四项全部符合标称型号才是正品；第五行是型号，之后四行是成色。</summary>
+        public const int AuthRows = 4;
+        public static bool IsAuth(int row) => row == RowCount || row == RowPin || row == RowPrint || row == RowSerial;

        /// <summary>各标签各取值对价格的影响（百分比，相加）：风扇叶片积灰 −4%、缺角 −12%；金手指发暗 −4%、氧化 −12%；挡板划痕 −2%；封条缺失 −6%。
        /// 型号、供电与风扇、丝印、序列号本身不扣价，它们决定的是这块卡是什么芯片。</summary>
@@ -73,7 +81,8 @@ namespace Decentralized.Domain
        {
            switch (row)
            {
-                case RowBuild: return claim.Tier != real.Tier;
+                case RowCount: return claim.Count != real.Count;
+                case RowPin: return claim.Pin != real.Pin;
                case RowPrint: return real.Print != 0 && claim.Print != real.Print;
                case RowSerial: return real.Serial != 0 && claim.Serial != real.Serial;
            }
@@ -108,7 +117,7 @@ namespace Decentralized.Domain
            if (row == RowSpec) return claim.Model != real.Model ? 2 : 0;
            if (IsEvidence(row, claim, real))
            {
-                exposed |= RowSpec | RowBuild;
+                exposed |= RowSpec | RowCount | RowPin | RowPrint | RowSerial;
                return 2;
            }
            if (wasExposed) return 0;
@@ -124,6 +133,7 @@ namespace Decentralized.Domain
            {
                if ((exposed & r) != 0) continue;
                if (r == RowSpec) { if (claim.Model != real.Model) lies |= r; }
+                else if (IsAuth(r)) { if (claim.Get(r) != real.Get(r)) lies |= r; }
                else if (claim.Get(r) != real.Get(r) && Pct(r, claim.Get(r)) > Pct(r, real.Get(r))) lies |= r;
            }
            return lies;
@@ -136,6 +146,7 @@ namespace Decentralized.Domain
            if (kind == DealerKind.Honest) return c;
            c.Model = u.Model;
            double hide = kind == DealerKind.Scammer ? 1.0 : Tuning.UsedMiddlemanHide;
+            c.CountSet = 0; c.PinSet = 0;
            foreach (int r in new[] { RowFan, RowFingers, RowBracket, RowPrint, RowSerial, RowSeal })
                if (rng.Chance(hide)) c = c.With(r, 0);
            return c;
@@ -23,6 +23,11 @@ namespace Decentralized.Domain
        /// 2 档次码与标称型号不符（贴的是原芯片的序列号）。后两种只出现在假卡上。</summary>
        public int Serial;

+        /// <summary>风扇数对不上标称型号（实物是真实芯片的风扇数）：0 对得上，1 对不上。只出现在假卡上。</summary>
+        public int CountBad;
+        /// <summary>供电口对不上标称型号（实物是真实芯片的供电口）：0 对得上，1 对不上。只出现在假卡上。</summary>
+        public int PinBad;
+
        public const int Variants = 3;

        /// <summary>每张卡自己的随机种子：老化类维度（风扇、金手指、挡板划痕）由它和当前健康度决定，每晚损耗后重新算，
@@ -56,13 +61,14 @@ namespace Decentralized.Domain
        public double HashFactor => FanHash[Fan] * FingerHash[Fingers];

        /// <summary>六位数字，存在物品标签上：风扇、金手指、挡板、丝印、封条、序列号。</summary>
-        public string Encode() => $"{Fan}{Fingers}{Bracket}{Print}{Sticker}{Serial}";
+        public string Encode() => $"{Fan}{Fingers}{Bracket}{Print}{Sticker}{Serial}{CountBad}{PinBad}";

        public static CardLook Decode(string s)
        {
-            if (s == null || (s.Length != 5 && s.Length != 6)) return default;
+            if (s == null || s.Length < 5 || s.Length > 8) return default;
            int D(int i) => Math.Max(0, Math.Min(Variants - 1, s[i] - '0'));
-            return new CardLook { Fan = D(0), Fingers = D(1), Bracket = D(2), Print = D(3), Sticker = D(4), Serial = s.Length > 5 ? D(5) : 0 };
+            int B(int i) => s.Length > i && s[i] == '1' ? 1 : 0;
+            return new CardLook { Fan = D(0), Fingers = D(1), Bracket = D(2), Print = D(3), Sticker = D(4), Serial = s.Length > 5 ? D(5) : 0, CountBad = B(6), PinBad = B(7) };
        }

        // 外观维度对应卡的真实状态：损耗、暴毙概率随之变化，价值走标签（见 CardLabels）
@@ -76,20 +82,28 @@ namespace Decentralized.Domain
        public double DeathFactor => FanDeath[Fan] * FingerDeath[Fingers];

        /// <summary>只在假卡上出现的取值：玩家一旦看到，就能肯定是假的。</summary>
-        public bool HasFakeSign => Print != 0 || Serial != 0;
+        public bool HasFakeSign => Print != 0 || Serial != 0 || CountBad != 0 || PinBad != 0;

        /// <summary>
        /// 生成外观。真卡：老化维度按健康度出现，封条缺失在二手卡上很常见，不会出现破绽类取值。
        /// 假卡：在三类破绽（接口数、丝印、手写序列号）里随机挑 1–3 处，再叠加老化与封条缺失。
        /// </summary>
-        public static CardLook Generate(Rng rng, double health, bool fake)
+        public static CardLook Generate(Rng rng, double health, bool fake, int labelTier = 3, int chipTier = 0)
        {
            var look = new CardLook { Seed = rng.NextUInt() | 1, Sticker = rng.Chance(fake ? 0.35 : 0.15 + 0.30 * (1 - Math.Max(0, Math.Min(100, health)) / 100.0)) ? 2 : 0 };
            if (fake)
            {
-                // 假卡本身就带着实物上的破绽（低档次的板子：供电口和风扇数对不上），此外骗子还可能重印丝印、补贴序列号
-                if (rng.Chance(0.55)) look.Print = rng.Chance(0.6) ? 1 : 2;
-                if (rng.Chance(0.65)) look.Serial = rng.Chance(0.55) ? 2 : 1;
+                // 四项真伪依据（风扇数、供电口、背面丝印、序列号）各自独立地露出破绽，至少一项；平均每张假卡约 1.5 项
+                bool countCan = Hardware.FanCount[chipTier] != Hardware.FanCount[labelTier], pinCan = Hardware.PinClass[chipTier] != Hardware.PinClass[labelTier];
+                double p = Tuning.FakeSignChance;
+                for (int tries = 0; tries < 30 && !look.HasFakeSign; tries++)
+                {
+                    look.CountBad = countCan && rng.Chance(p) ? 1 : 0;
+                    look.PinBad = pinCan && rng.Chance(p) ? 1 : 0;
+                    look.Print = rng.Chance(p) ? (rng.Chance(0.6) ? 1 : 2) : 0;
+                    look.Serial = rng.Chance(p) ? (rng.Chance(0.55) ? 2 : 1) : 0;
+                }
+                if (!look.HasFakeSign) look.Serial = 1;
            }
            return look.Appearance(health);
        }
@@ -32,6 +32,8 @@ namespace Decentralized.Domain
        /// <summary>各档次的实物特征：供电口针数（旗舰是两个 8 针）与风扇数量。</summary>
        public static readonly string[] PowerPins = { "6", "8", "8", "8+8" };
        public static readonly int[] FanCount = { 1, 2, 3, 3 };
+        /// <summary>各档次的供电口：0 = 6 针，1 = 8 针，2 = 双 8 针。</summary>
+        public static readonly int[] PinClass = { 0, 1, 1, 2 };

        public const string Probidia = "Probidia", Pmd = "PMD", RatDigg = "RatDigg";

@@ -109,6 +111,11 @@ namespace Decentralized.Domain
        public HardwareSpec Label => Hardware.Specs[Model];
        public HardwareSpec Chip => Hardware.Specs[FakeOf ?? Model];

+        /// <summary>实物上的风扇数：对得上标称型号时是标称档次的，对不上（假卡的破绽）时是真实芯片的。</summary>
+        public int ObservedCount => Hardware.FanCount[(Look.CountBad != 0 ? Chip : Label).Tier];
+        /// <summary>实物上的供电口：0 = 6 针，1 = 8 针，2 = 双 8 针；规则同风扇数。</summary>
+        public int ObservedPin => Hardware.PinClass[(Look.PinBad != 0 ? Chip : Label).Tier];
+
        /// <summary>当前算力：健康 ≥ 50 时满算力，低于 50 线性降到健康 0 时的 60%。</summary>
        public double Hash(ModuleBonus b)
        {
@@ -88,6 +88,8 @@ namespace Decentralized.Domain
        public const int UsedFirstDay = 3;
        /// <summary>显卡价值 = 型号定价 ×（下限 + (1 − 下限) × 健康度）。</summary>
        public const double CardValueFloor = 0.25;
+        /// <summary>假卡的四项真伪依据（风扇数、供电口、背面丝印、序列号）各自露出破绽的概率（至少露出一项）；约对应平均 1.5 项。</summary>
+        public const double FakeSignChance = 0.27;
        /// <summary>黑市、鉴定等处二手卡的健康度范围（均匀取）。</summary>
        public const double CardHealthMin = 25, CardHealthMax = 85;
        /// <summary>二手贩子带来的卡的健康度范围，按老实人、中间商、骗子：越不老实卡越旧，平均每张卡约 0.5 / 1.5 / 2.5 项成色问题（叶片、金手指、挡板、封条）。</summary>
@@ -141,7 +141,9 @@ namespace Decentralized
            return y + h;
        }

-        private static string Front(string brand, int tier) => $"gpu_big_{brand}_f_t{tier}";
+        /// <summary>正面底图：供电口类别（0 = 6 针，1 = 8 针，2 = 双 8 针）与风扇数（1 到 3）各自独立。</summary>
+        private static string Front(string brand, int pin, int count) => $"gpu_big_{brand}_f_p{pin}n{count}";
+        private static string Front(string brand, int tier) => Front(brand, Hardware.PinClass[tier], Hardware.FanCount[tier]);
        private static int Fans(int tier) => Hardware.FanCount[tier];

        private static void Caption(PaperUI b, float x, float y, float w, string text, string color = null)
@@ -150,6 +152,20 @@ namespace Decentralized
            if (color != null) b.Last.color = color;
        }

+        /// <summary>背面贴纸上的序列号：贴纸在大图 (142, 91) 附近，随图的缩放摆放。</summary>
+        private static void SerialOnSticker(PaperUI b, float ax, float ay, float scale, string serial)
+        {
+            float cx = ax + 142f * scale, cy = ay + 91f * scale;
+            b.AddText(cx - 26f * scale, cy - 4.5f, 52f * scale, 9f, serial, "caption", align: "center", fontSize: 3.2f * scale / 0.78f);
+            b.Last.color = "#1B1B1B";
+        }
+
+        private static string SampleSerial(string model, string chip = null, int kind = 0)
+        {
+            var u = new Unit { Model = model, FakeOf = chip, Health = 100, Look = new CardLook { Seed = 31337, Serial = kind } };
+            return CardLabels.SerialText(u);
+        }
+
        // ---- 1 概述 ----
        private static void Page1(PaperUI b)
        {
@@ -164,7 +180,7 @@ namespace Decentralized
            b.Last.fontSize = 7f;
        }

-        // ---- 2 档次 ----
+        // ---- 2 显卡型号 ----
        private static void Page2(PaperUI b)
        {
            float y = NewPage(b);
@@ -184,43 +200,102 @@ namespace Decentralized
                }
                y = rowBottom + 4f;
            }
-            Text(b, y + 2f, L.T("gg.p2.models"), "body");
        }

-        // ---- 3 叶片 ----
+        // ---- 3 风扇数 ----
        private static void Page3(PaperUI b)
+        {
+            float y = NewPage(b);
+            y = Section(b, y, L.T("gg.count.h"));
+            y = Text(b, y, L.T("gg.count.body"), gap: 6f);
+            for (int n = 1; n <= 3; n++)
+            {
+                float bottom = Art(b, X + (W - 96f) / 2, y, 0.5f, Front("probidia", 1, n));
+                Caption(b, X, bottom, W, L.T("lbl.count." + n));
+                y = bottom + 15f;
+            }
+        }
+
+        // ---- 4 供电口 ----
+        private static void Page4(PaperUI b)
+        {
+            float y = NewPage(b);
+            y = Section(b, y, L.T("gg.pin.h"));
+            y = Text(b, y, L.T("gg.pin.body"), gap: 6f);
+            for (int p = 0; p < 3; p++)
+            {
+                float bottom = Art(b, X + (W - 96f) / 2, y, 0.5f, Front("probidia", p, 2));
+                Caption(b, X, bottom, W, L.T("lbl.pin." + p));
+                y = bottom + 15f;
+            }
+        }
+
+        // ---- 5 序列号 ----
+        private static void Page5(PaperUI b)
+        {
+            float y = NewPage(b);
+            y = Section(b, y, L.T("gg.serial.h"));
+            y = Text(b, y, L.T("gg.serial.body"), gap: 6f);
+            float ax = X + (W - 150f) / 2;
+            float bottom = Art(b, ax, y, 0.78f, "gpu_big_probidia_b", "gpu_big_ov_print_normal_rtx80");
+            SerialOnSticker(b, ax, y, 0.78f, SampleSerial("RTX80"));
+            Caption(b, X, bottom + 1, W, L.T("gg.serial.cap"));
+            y = bottom + 16f;
+            y = Text(b, y, L.T("gg.serial.pb"), gap: 4f);
+            y = Text(b, y, L.T("gg.serial.md"), gap: 8f);
+            Text(b, y, L.T("gg.serial.rule"), "body");
+        }
+
+        // ---- 6 背面丝印 ----
+        private static void Page6(PaperUI b)
+        {
+            float y = NewPage(b);
+            y = Section(b, y, L.T("gg.print.h"));
+            string[] kinds = { "normal", "stamp", "skew" };
+            for (int s = 0; s < 3; s++)
+            {
+                string model = s == 1 ? "rtx60" : "rtx80";
+                float ax = X + (W - 96f) / 2;
+                float bottom = Art(b, ax, y, 0.5f, "gpu_big_probidia_b", $"gpu_big_ov_print_{kinds[s]}_{model}");
+                SerialOnSticker(b, ax, y, 0.5f, SampleSerial("RTX80"));
+                Caption(b, X, bottom, W, L.T("gg.print." + s), s == 0 ? null : Bad);
+                y = bottom + 14f;
+            }
+            Text(b, y, L.T("gg.print.note"), "body");
+        }
+
+        // ---- 7 叶片与金手指 ----
+        private static void Page7(PaperUI b)
        {
            float y = NewPage(b);
            y = Section(b, y, L.T("gg.fan.h"));
+            float cw = W / 3;
+            float bottom = y;
            for (int s = 0; s < 3; s++)
            {
                var layers = new List<string> { Front("probidia", 1) };
                if (s == 1) layers.Add("gpu_big_ov_fan_dust2_" + Fans(1));
                if (s == 2) { layers.Add("gpu_big_ov_fan_dust1_" + Fans(1)); layers.Add("gpu_big_ov_fan_chip_" + Fans(1)); }
-                float bottom = Art(b, X + (W - 96f) / 2, y, 0.5f, layers.ToArray());
-                Caption(b, X, bottom, W, T("gg.fan." + s), s == 0 ? null : Bad);
-                y = bottom + 15f;
+                float bx = Art(b, X + s * cw + (cw - 78f) / 2, y, 0.4f, layers.ToArray());
+                Caption(b, X + s * cw, bx, cw, T("gg.fan." + s), s == 0 ? null : Bad);
+                bottom = bx + 24f;
            }
-        }
-
-        // ---- 4 金手指 ----
-        private static void Page4(PaperUI b)
-        {
-            float y = NewPage(b);
+            y = bottom + 10f;
            y = Section(b, y, L.T("gg.fin.h"));
            for (int s = 0; s < 3; s++)
            {
                var layers = new List<string> { Front("probidia", 1) };
                if (s == 1) layers.Add("gpu_big_ov_fin_dim");
                if (s == 2) layers.Add("gpu_big_ov_fin_oxide");
-                float bottom = Art(b, X + (W - 96f) / 2, y, 0.5f, layers.ToArray());
-                Caption(b, X, bottom, W, T("gg.fin." + s), s == 0 ? null : Bad);
-                y = bottom + 15f;
+                float bx = Art(b, X + s * cw + (cw - 78f) / 2, y, 0.4f, layers.ToArray());
+                Caption(b, X + s * cw, bx, cw, T("gg.fin." + s), s == 0 ? null : Bad);
+                bottom = bx + 24f;
            }
+            Text(b, bottom + 6f, L.T("gg.wear.note"), "body");
        }

-        // ---- 5 挡板与封条 ----
-        private static void Page5(PaperUI b)
+        // ---- 8 挡板与封条 ----
+        private static void Page8(PaperUI b)
        {
            float y = NewPage(b);
            y = Section(b, y, L.T("gg.brk.h"));
@@ -241,66 +316,35 @@ namespace Decentralized
            {
                var layers = new List<string> { "gpu_big_probidia_b", "gpu_big_ov_print_normal_rtx70" };
                if (s == 1) layers.Add("gpu_big_ov_seal_missing");
-                float bx = Art(b, X + s * cw + (cw - 120f) / 2, y, 0.625f, layers.ToArray());
+                float ax = X + s * cw + (cw - 120f) / 2;
+                float bx = Art(b, ax, y, 0.625f, layers.ToArray());
+                SerialOnSticker(b, ax, y, 0.625f, SampleSerial("RTX70"));
                Caption(b, X + s * cw, bx, cw, T(s == 0 ? "gg.seal.0" : "gg.seal.2"), s == 0 ? null : Bad);
                bottom = bx + 12f;
            }
-            Text(b, bottom + 8f, L.T("gg.wear.note"), "body");
        }

-        // ---- 6 序列号 ----
-        private static void Page6(PaperUI b)
+        // ---- 9 指出 ----
+        private static void Page9(PaperUI b)
        {
            float y = NewPage(b);
-            y = Section(b, y, L.T("gg.serial.h"));
-            y = Text(b, y, L.T("gg.serial.body"), gap: 6f);
-            float bottom = Art(b, X + (W - 150f) / 2, y, 0.78f, "gpu_big_probidia_b", "gpu_big_ov_print_normal_rtx80");
-            Caption(b, X, bottom + 1, W, L.T("gg.serial.cap"));
-            y = bottom + 16f;
-            y = Text(b, y, L.T("gg.serial.pb"), gap: 4f);
-            y = Text(b, y, L.T("gg.serial.md"), gap: 8f);
-            Text(b, y, L.T("gg.serial.rule"), "body");
-        }
-
-        // ---- 7 背面丝印 ----
-        private static void Page7(PaperUI b)
-        {
-            float y = NewPage(b);
-            y = Section(b, y, L.T("gg.print.h"));
-            string[] kinds = { "normal", "stamp", "skew" };
-            for (int s = 0; s < 3; s++)
-            {
-                string model = s == 1 ? "rtx60" : "rtx80";
-                float bottom = Art(b, X + (W - 96f) / 2, y, 0.5f, "gpu_big_probidia_b", $"gpu_big_ov_print_{kinds[s]}_{model}");
-                Caption(b, X, bottom, W, L.T("gg.print." + s), s == 0 ? null : Bad);
-                y = bottom + 14f;
-            }
-            Text(b, y, L.T("gg.print.note"), "body");
-        }
-
-        // ---- 8 卖家与指出 ----
-        private static void Page8(PaperUI b)
-        {
-            float y = NewPage(b);
-            y = Section(b, y, L.T("gg.seller.h"));
-            y = Text(b, y, T("gg.seller.body"), gap: 8f);
            y = Section(b, y, L.T("gg.point.h"));
            Text(b, y, T("gg.point.body"), "body");
+            foreach (var e in Examples) ExamplePage(b, e);
        }

        // ---- 9 起：鉴定示例 ----
-        private sealed class Ex { public string Title, Label, Chip; public int Health, Fan, Fingers, Bracket, Seal; }
+        private sealed class Ex { public string Title, Label, Chip; public int Health, Fan, Fingers, Bracket, Seal, CountBad, PinBad, SerialBad; }

        private static readonly Ex[] Examples =
        {
            new Ex { Title = "gg.ex.h", Label = "RTX80", Health = 60, Fan = 2, Fingers = 1, Seal = 2 },
            new Ex { Title = "gg.ex.h3", Label = "RX800", Health = 35, Fan = 2, Fingers = 2, Bracket = 1, Seal = 2 },
-            new Ex { Title = "gg.ex.h2", Label = "RTX90", Chip = "RTX60", Health = 90, Fan = 1 },
+            new Ex { Title = "gg.ex.h2", Label = "RTX90", Chip = "RTX60", Health = 90, Fan = 1, CountBad = 1, SerialBad = 2 },
            new Ex { Title = "gg.ex.h4", Label = "RTX70", Health = 85, Fan = 1 },
            new Ex { Title = "gg.ex.h5", Label = "RX70", Health = 100 },
        };

-        private static void Page9(PaperUI b) { foreach (var e in Examples) ExamplePage(b, e); }

        private static string Brand(string model) => Hardware.Specs[model].Brand.ToString();

@@ -309,10 +353,11 @@ namespace Decentralized
            float y = NewPage(b);
            y = Section(b, y, L.T(e.Title));
            string real = e.Chip ?? e.Label;
-            var u = new Unit { Model = e.Label, FakeOf = e.Chip, Health = e.Health, Look = new CardLook { Seed = 0, Fan = e.Fan, Fingers = e.Fingers, Bracket = e.Bracket, Sticker = e.Seal } };
+            var u = new Unit { Model = e.Label, FakeOf = e.Chip, Health = e.Health, Look = new CardLook { Seed = 31337, Fan = e.Fan, Fingers = e.Fingers, Bracket = e.Bracket, Sticker = e.Seal, CountBad = e.CountBad, PinBad = e.PinBad, Serial = e.SerialBad } };
            long baseV = CardValue.Of(real, e.Health);
-            var layers = new List<string> { Front(Hardware.Specs[real].Brand == "PMD" ? "pmd" : "probidia", Hardware.Specs[real].Tier) };
-            int fans = Fans(Hardware.Specs[real].Tier);
+            string brandKey = Hardware.Specs[real].Brand == "PMD" ? "pmd" : "probidia";
+            var layers = new List<string> { Front(brandKey, u.ObservedPin, u.ObservedCount) };
+            int fans = u.ObservedCount;
            if (e.Fan == 1) layers.Add("gpu_big_ov_fan_dust2_" + fans);
            if (e.Fan == 2) { layers.Add("gpu_big_ov_fan_dust1_" + fans); layers.Add("gpu_big_ov_fan_chip_" + fans); }
            if (e.Fingers == 1) layers.Add("gpu_big_ov_fin_dim");
@@ -321,7 +366,8 @@ namespace Decentralized
            float bottom = Art(b, X + (W - 140f) / 2, y, 0.73f, layers.ToArray());
            y = bottom + 6f;
            string name = Hardware.Specs[e.Label].Brand + " " + Items.DisplayModel(e.Label);
-            y = Text(b, y, L.T("gg.ex.card", name, e.Health), "body", align: "center", gap: 8f);
+            y = Text(b, y, L.T("gg.ex.card", name, e.Health), "body", align: "center", gap: 3f);
+            y = Text(b, y, L.T("gg.ex.serial", CardLabels.SerialText(u)), "caption", Ink, "center", 8f);
            const float lx = X + 20f, lw = W - 40f;
            if (e.Chip != null)
            {
@@ -16,9 +16,9 @@ namespace Decentralized
    /// </summary>
    public sealed class GpuInspectView : MonoBehaviour
    {
-        private const float RowH = 30f, CardScale = 3f, PanelTop = -112f, DetailH = 26f, GroupGap = 8f;
-        private const int RowCount = 5;
-        private TextMeshProUGUI detailText, priceText;
+        private const float RowH = 26f, CardScale = 3f, PanelTop = -112f, DetailH = 26f, GroupGap = 7f;
+        private static readonly int RowCount = CardLabels.Rows.Length;
+        private TextMeshProUGUI priceText;
        private static GpuInspectView instance;
        private RectTransform root, cardRoot;
        private Button flip;
@@ -28,9 +28,9 @@ namespace Decentralized
        private bool hidGlass;
        private Transform buttonTemplate;
        private TMP_FontAsset font;
-        private readonly TextMeshProUGUI[] rowName = new TextMeshProUGUI[RowCount], rowText = new TextMeshProUGUI[RowCount];
-        private readonly Button[] rowButton = new Button[RowCount];
-        private readonly TextMeshProUGUI[] rowButtonText = new TextMeshProUGUI[RowCount];
+        private readonly TextMeshProUGUI[] rowName = new TextMeshProUGUI[16], rowText = new TextMeshProUGUI[16];
+        private readonly Button[] rowButton = new Button[16];
+        private readonly TextMeshProUGUI[] rowButtonText = new TextMeshProUGUI[16];
        private TextMeshProUGUI serialText;

        public static void Ensure()
@@ -173,29 +173,33 @@ namespace Decentralized
            if (buttonTemplate == null) return;
            font = buttonTemplate.GetComponentInChildren<TextMeshProUGUI>()?.font;
            if (font != null) serialText.font = font;
-            // 标签区：深色底加浅色边框，和上面的大图分开
-            float panelH = RowCount * RowH + 10f + DetailH + GroupGap, panelY = PanelTop - panelH / 2;
+            // 标签区：深色底加浅色边框，和上面的大图分开。三组：四项真伪依据、型号、四项成色，最下面一行是标签价
+            float panelH = RowCount * RowH + 10f + DetailH + GroupGap * 2, panelY = PanelTop - panelH / 2;
            MakeRect(root, "LabelFrame", new Vector2(0, panelY), new Vector2(648, panelH + 8), new Color(0.78f, 0.68f, 0.45f, 1f));
            MakeRect(root, "LabelBack", new Vector2(0, panelY), new Vector2(640, panelH), new Color(0.10f, 0.11f, 0.14f, 0.96f));
-            MakeRect(root, "LabelDivider", new Vector2(0, PanelTop - 5 - RowH * CardLabels.AuthRows - DetailH - GroupGap / 2), new Vector2(620, 2), new Color(0.78f, 0.68f, 0.45f, 0.8f));
-            detailText = MakeText(root, "Detail", new Vector2(-90, PanelTop - 5 - RowH * CardLabels.AuthRows - DetailH / 2), new Vector2(450, DetailH), TextAlignmentOptions.Left, 17);
-            priceText = MakeText(root, "LabelPrice", new Vector2(230, PanelTop - 5 - RowH * CardLabels.AuthRows - DetailH / 2), new Vector2(170, DetailH), TextAlignmentOptions.Right, 19);
+            MakeRect(root, "LabelDivider1", new Vector2(0, GroupTop(CardLabels.AuthRows) + GroupGap / 2 + 1), new Vector2(620, 2), new Color(0.78f, 0.68f, 0.45f, 0.8f));
+            MakeRect(root, "LabelDivider2", new Vector2(0, GroupTop(CardLabels.AuthRows + 1) + GroupGap / 2 + 1), new Vector2(620, 2), new Color(0.78f, 0.68f, 0.45f, 0.5f));
+            MakeRect(root, "LabelDivider3", new Vector2(0, PanelTop - 5 - RowH * RowCount - GroupGap * 2 - 1), new Vector2(620, 2), new Color(0.78f, 0.68f, 0.45f, 0.8f));
+            priceText = MakeText(root, "LabelPrice", new Vector2(165, PanelTop - 5 - RowH * RowCount - GroupGap * 2 - DetailH / 2 - 2), new Vector2(300, DetailH), TextAlignmentOptions.Right, 21);
            priceText.color = new Color(1f, 0.85f, 0.45f);
-            PledgerSkin.Fit(priceText); PledgerSkin.Fit(detailText);
+            PledgerSkin.Fit(priceText);
            flip = MakeButton(root, "Flip", new Vector2(0, PanelTop - panelH - 24), new Vector2(200, 30), out flipText);
            flip.onClick.AddListener(() => { if (shown != null) Items.Flip(shown); });
            for (int i = 0; i < RowCount; i++)
            {
                int row = CardLabels.Rows[i];
-                float y = PanelTop - 5 - RowH * (i + 0.5f) - (i >= CardLabels.AuthRows ? DetailH + GroupGap : 0f);
-                rowName[i] = MakeText(root, "RowName" + i, new Vector2(-255, y), new Vector2(110, RowH), TextAlignmentOptions.Left, 22);
-                rowText[i] = MakeText(root, "RowText" + i, new Vector2(-30, y), new Vector2(330, RowH), TextAlignmentOptions.Left, 22);
+                float y = GroupTop(i) - RowH / 2;
+                rowName[i] = MakeText(root, "RowName" + i, new Vector2(-245, y), new Vector2(130, RowH), TextAlignmentOptions.Left, 20);
+                rowText[i] = MakeText(root, "RowText" + i, new Vector2(-20, y), new Vector2(330, RowH), TextAlignmentOptions.Left, 20);
                rowButton[i] = MakeButton(root, "RowButton" + i, new Vector2(245, y), new Vector2(110, RowH - 3), out rowButtonText[i]);
                rowButton[i].onClick.AddListener(() => Log.Guard("标签栏", () => OnRowButton(row)));
            }
        }

-        private static string RowKey(int row) => row == CardLabels.RowSpec ? "spec" : row == CardLabels.RowBuild ? "build" : row == CardLabels.RowFan ? "fan" : row == CardLabels.RowFingers ? "fingers"
+        /// <summary>第 i 行的上沿（三组之间各留一道间隔）。</summary>
+        private static float GroupTop(int i) => PanelTop - 5 - RowH * i - (i >= CardLabels.AuthRows ? GroupGap : 0f) - (i >= CardLabels.AuthRows + 1 ? GroupGap : 0f);
+
+        private static string RowKey(int row) => row == CardLabels.RowSpec ? "spec" : row == CardLabels.RowCount ? "count" : row == CardLabels.RowPin ? "pin" : row == CardLabels.RowFan ? "fan" : row == CardLabels.RowFingers ? "fingers"
            : row == CardLabels.RowBracket ? "bracket" : row == CardLabels.RowPrint ? "print" : row == CardLabels.RowSerial ? "serial" : "seal";

        private static string ValueText(int row, int value) => row == CardLabels.RowSpec ? "" : L.T("lbl." + RowKey(row) + "." + (row == CardLabels.RowSeal && value == 1 ? 0 : value));
@@ -225,7 +229,7 @@ namespace Decentralized
                int row = CardLabels.Rows[i];
                rowName[i].text = RowName(row);
                rowName[i].color = i < CardLabels.AuthRows ? new Color(1f, 0.85f, 0.45f) : new Color(0.6f, 0.85f, 1f);   // 真伪行金黄，成色行浅蓝
-                rowName[i].fontSize = 22; PledgerSkin.Fit(rowName[i]);
+                rowName[i].fontSize = 20; PledgerSkin.Fit(rowName[i]); PledgerSkin.Fit(rowText[i]);
                string text;
                Color color = new Color(0.96f, 0.98f, 1f);
                string Show(Claim c) => row == CardLabels.RowSpec ? DisplayModel(c.Model) : ValueText(row, c.Get(row));
@@ -234,24 +238,16 @@ namespace Decentralized
                {
                    text = Show(real);
                    bool lied = row == CardLabels.RowSpec ? claim.Value.Model != real.Model : claim.Value.Get(row) != real.Get(row);
-                    if (lied) { color = new Color(1f, 0.45f, 0.4f); text += L.T("lbl.said", row == CardLabels.RowBuild ? L.T("lbl.tier." + claim.Value.Tier) : Show(claim.Value)); }
+                    if (lied) { color = new Color(1f, 0.45f, 0.4f); text += L.T("lbl.said", Show(claim.Value)); }
                    else color = new Color(0.5f, 1f, 0.55f);
                }
                else text = Show(claim.Value);
                rowText[i].text = text;
                rowText[i].color = color;
-                bool editable = row != CardLabels.RowBuild;
+                bool editable = row != CardLabels.RowCount && row != CardLabels.RowPin;
                rowButton[i].gameObject.SetActive(canEdit ? editable : canPoint && (exposed & row) == 0);
                rowButtonText[i].text = L.T(canEdit ? "lbl.edit" : "lbl.point");
            }
-            // 型号行：没拆穿之前不写依据；拆穿之后列出实际查到的问题
-            if (detailText != null)
-            {
-                bool spec = (exposed & CardLabels.RowSpec) != 0;
-                string detail = claim == null || !spec ? "" : Evidence(u, claim.Value, real);
-                detailText.text = detail;
-                detailText.color = spec ? new Color(1f, 0.7f, 0.6f) : new Color(0.75f, 0.78f, 0.85f);
-            }
            if (priceText != null) priceText.text = L.T("lbl.price", item.unitValue);
            if (flipText != null) flipText.text = L.T(Items.IsBack(item) ? "inspect.flip.front" : "inspect.flip.back");
            // 贴纸上的序列号：只在背面显示
@@ -264,16 +260,6 @@ namespace Decentralized
            }
        }

-        /// <summary>型号真伪的依据：实物与卖家说法对不上的地方（供电口与风扇数、序列号、背面丝印）。</summary>
-        private static string Evidence(Unit u, Claim claim, Claim real)
-        {
-            var parts = new List<string>();
-            if (claim.Tier != real.Tier) parts.Add(L.T("lbl.ev.build", L.T("lbl.tier." + real.Tier), Hardware.PowerPins[real.Tier], Hardware.FanCount[real.Tier]));
-            if (real.Serial != 0) parts.Add(L.T("lbl.ev.serial." + real.Serial));
-            if (real.Print != 0) parts.Add(L.T("lbl.ev.print." + real.Print));
-            return parts.Count == 0 ? L.T("lbl.ev.none") : L.T("lbl.ev.prefix") + string.Join("；", parts);
-        }
-
        private static string DisplayModel(string model) => Items.DisplayModel(model);

        private void OnRowButton(int row)
@@ -191,7 +191,7 @@ namespace Decentralized
        public static GameItem NewCard(string model, double health, string fakeOf, Rng rng, DealerKind? seller = null, int markupPct = 0)
        {
            var item = ModHelper.SpawnItem(GpuId(model));
-            var u = new Unit { Model = model, FakeOf = fakeOf, Health = health, Look = CardLook.Generate(rng, health, fakeOf != null) };
+            var u = new Unit { Model = model, FakeOf = fakeOf, Health = health, Look = CardLook.Generate(rng, health, fakeOf != null, Hardware.Specs[model].Tier, fakeOf != null ? Hardware.Specs[fakeOf].Tier : Hardware.Specs[model].Tier) };
            if (health >= 100 && fakeOf == null) u.Look.Sticker = 0;   // 全新卡：封条完好
            Store(item, u);
            if (seller != null)
@@ -233,10 +233,10 @@ namespace Decentralized
            var rng = Session.Data.Rng;
            int found = 0;
            foreach (int r in CardLabels.Rows)
-                if ((lies & r) != 0 && rng.Chance(r == CardLabels.RowSpec && claim.Value.Tier != Claim.Truth(u).Tier ? Tuning.CustomerSpotTierMismatch : Tuning.CustomerSpotChance))
+                if ((lies & r) != 0 && rng.Chance((r == CardLabels.RowCount || r == CardLabels.RowPin) ? Tuning.CustomerSpotTierMismatch : Tuning.CustomerSpotChance))
                {
                    found |= r;
-                    if (r != CardLabels.RowSpec && CardLabels.IsEvidence(r, claim.Value, Claim.Truth(u))) found |= CardLabels.RowSpec | CardLabels.RowBuild;
+                    if (r != CardLabels.RowSpec && CardLabels.IsEvidence(r, claim.Value, Claim.Truth(u))) found |= CardLabels.RowSpec | CardLabels.RowCount | CardLabels.RowPin | CardLabels.RowPrint | CardLabels.RowSerial;
                }
            if (found == 0) return;
            long before = item.unitValue;
@@ -262,7 +262,7 @@ namespace Decentralized
        public static int Exposed(GameItem item)
        {
            int e = item.IsTag(ExposedTag) ? item.GetTagReadonly(ExposedTag).GetInt() : 0;
-            if ((e & CardLabels.RowSpec) != 0) e |= CardLabels.RowSpec | CardLabels.RowBuild | CardLabels.RowSerial | CardLabels.RowPrint;
+            if ((e & CardLabels.RowSpec) != 0) e |= CardLabels.RowSpec | CardLabels.RowCount | CardLabels.RowPin | CardLabels.RowSerial | CardLabels.RowPrint;
            return e;
        }

@@ -402,7 +402,7 @@ namespace Decentralized

        /// <summary>当前面的底图名与叠加图名：正面三个维度，背面丝印与贴纸；烧毁的卡不叠。</summary>
        /// <summary>实物上的风扇数：由真实芯片的档次决定（低档次的板子套高档次的壳，风扇数露馅）。</summary>
-        public static int FansOf(Unit u) => Hardware.FanCount[Hardware.Specs[u.FakeOf ?? u.Model].Tier];
+        public static int FansOf(Unit u) => u.ObservedCount;

        public static string LookKeys(GameItem item, List<string> overlays)
        {
@@ -424,7 +424,7 @@ namespace Decentralized
                overlays.Add((l.Print == 2 ? "gpu_ov_txs_" : "gpu_ov_txt_") + model.ToLowerInvariant());
                if (l.Sticker == 2) overlays.Add("gpu_ov_stk2");
            }
-            return brand + (back ? "_b" : "_f_t" + Hardware.Specs[u.FakeOf ?? u.Model].Tier);
+            return brand + (back ? "_b" : $"_f_p{u.ObservedPin}n{u.ObservedCount}");
        }

        public static Sprite ModSprite(string key)
@@ -109,7 +109,7 @@ lbl.bracket.0,Intakt
 lbl.bracket.1,Zerkratzt
 lbl.serial.0,Gültig
 lbl.serial.1,Ungültiger Werkscode oder falsche Länge
-lbl.serial.2,Stufencode stimmt nicht mit Modell überein
+lbl.serial.2,Modellcode passt nicht zum Modell
 lbl.seal.0,Intakt
 lbl.seal.2,Fehlt
 lbl.tier.0,Einsteiger
@@ -820,17 +820,9 @@ settings.risk_scale_desc,"Multipliziert die Wahrscheinlichkeit von Betrug, Rug P
 settings.mining_scale,Mining-Ertragsfaktor
 settings.mining_scale_desc,Multipliziert die Blockbelohnung der Mining-Geräte. Gilt für alle Spielstände.
 gg.header,Handelsverband
-gg.p1.body,"Grafikkarten sind das Herzstück jedes Mining-Rigs und die Ware, die auf dem Gebrauchtmarkt am häufigsten gefälscht wird.\nDer Wert einer Karte hängt vom Modell des echten Chips und von ihrer Haltbarkeit ab; jede sichtbare Abnutzung senkt den Preis.\n\nDieses Handbuch vermittelt das gesamte Wissen, das zur Bewertung einer Grafikkarte nötig ist."
 gg.p1.cap,Grafikkarte
 gg.p1.makers,"Auf der Station gibt es zwei gängige Hersteller:\n\n      - Probidia (""PB"")\n      - PMD (""MD"")"
 gg.p1.note,"Unabhängig vom Hersteller hängt der Wert einer Karte nur vom Listenpreis des echten Chips und ihrer Haltbarkeit ab: bei voller Haltbarkeit entspricht er dem Listenpreis, bei Haltbarkeit 0 bleiben nur {CardValueFloor:%}."
-gg.p2.h,Kartenstufen
-gg.p2.body,Die Stufe bestimmt Stromanschluss und Lüfterzahl. Das Modell ist nur ein Anzeigename; die echte Stufe zeigt die Hardware.\nEine Fälschung ist ein Chip niedriger Stufe in einem Gehäuse hoher Stufe; Leistung und Wert richten sich nach dem Chip darin.
-gg.tier.0,"Einsteiger (6-Pin, 1 Lüfter)"
-gg.tier.1,"Mittelklasse (8-Pin, 2 Lüfter)"
-gg.tier.2,"Oberklasse (8-Pin, 3 Lüfter)"
-gg.tier.3,"Flaggschiff (2×8-Pin, 3 Lüfter)"
-gg.p2.models,"Probidia: RTX 60 / 70 / 80 / 90\nPMD: RX 70 / 80 / 800 / 900\nDie Modelle entsprechen in dieser Reihenfolge Einsteiger, Mittelklasse, Oberklasse und Flaggschiff."
 gg.fan.h,Lüfterblätter
 gg.fan.0,Sauber (Preis unverändert)
 gg.fan.1,Verstaubt (-{CardFanDust:%})
@@ -847,21 +839,14 @@ gg.seal.0,Intakt (Preis unverändert)
 gg.seal.2,Fehlt (-{CardSealMissing:%})
 gg.wear.note,"Lüfterblätter, Kontakte und Slotblende verschlechtern sich mit der nächtlichen Abnutzung und werden nur schlechter; das Siegel ist ein festes Merkmal. Der Zustand beeinflusst auch Hashrate, Abnutzung und Durchbrenn-Wahrscheinlichkeit."
 gg.serial.h,Seriennummer
-gg.serial.body,"Die Seriennummer steht auf einem Aufkleber auf der Rückseite, und zwar als Präfix, Stufencode, Bindestrich, zweistelliger Werkscode, Bindestrich und vierstellige Laufnummer, zum Beispiel PB2-21-6251."
 gg.serial.cap,Rückseite (Seriennummer)
 gg.serial.pb,"Probidia (""PB"")\n      Gültige Werkscodes: 11, 12, 21, 34, 47"
 gg.serial.md,"PMD (""MD"")\n      Gültige Werkscodes: 13, 22, 35, 41, 58"
-gg.serial.rule,"Die Stufencodes 1 bis 4 reichen von Einsteiger bis Flaggschiff.\nEin Stufencode, der nicht zum Modell passt (der Aufkleber gehört zum Originalchip), oder ein ungültiger Werkscode bzw. eine falsche Länge (nachträglich angebrachter Aufkleber) kennzeichnet eine Fälschung. Der Werkscode dient nur dem Echtheitsnachweis und ändert den Preis nicht."
 gg.print.h,Aufdruck hinten
 gg.print.0,Stimmt mit Modell überein
 gg.print.1,Anderes Modell (Fälschung)
 gg.print.2,"Nachdruck, schief (Fälschung)"
-gg.print.note,"Anschluss und Lüfterzahl stammen vom echten Chip, daher passt eine Fälschung nie zum angegebenen Modell. Seriennummer und Aufdruck können täuschend echt gemacht sein; ohne Mängel ist eine Karte also nicht automatisch echt."
-gg.seller.h,Verkäuferangaben
-gg.seller.body,"Gebrauchthardware-Dealer gibt es in drei Arten:\n\n      - Ehrlich: sagt die Wahrheit.\n      - Zwischenhändler: gibt jeden Punkt mit einer Wahrscheinlichkeit von {UsedMiddlemanHide:%} als einwandfrei an und schlägt {UsedMiddlemanMarkup:%} auf den Preis auf; {UsedFakeMiddleman:%} der Karten sind gefälscht.\n      - Betrüger: gibt alles als einwandfrei an, etwa {UsedFakeScammer:%} der Karten sind gefälscht, und verlangt den Preis des angegebenen Modells.\n\nBis zum Kauf gilt die Angabe des Verkäufers; danach zeigt die Karte ihren wahren Zustand."
 gg.point.h,Beanstanden
-gg.point.body,"Mit der Lupe prüfen; in der Beschriftungsleiste steht rechts in jeder Zeile ""Beanstanden"". Wird ein verschwiegenes Problem beanstandet, wechselt die Zeile zum wahren Zustand und der Preis sinkt um die Differenz; wird etwas Zutreffendes beanstandet, lehnt der Verkäufer ab und das Ansehen sinkt.\nWird das Modell beanstandet, wechselt es zum echten Chip und die gefundenen Probleme werden aufgelistet.\n\nKarten von Kunden der Prüfgilde tragen ebenfalls eine Angabe: Beanstandungen ändern die Schätzung, bis der richtige Wert gemeldet wird. Wird die eigene Karte einem Kunden gezeigt, bemerkt er jeden verschwiegenen Punkt mit einer Wahrscheinlichkeit von {CustomerSpotChance:%}."
-gg.ex.h,Prüfbeispiel
 gg.ex.card,"Beispiel: {0}, Haltbarkeit {1}%"
 gg.ex.base,Grundwert: +{0}
 gg.ex.fan,Lüfterblatt abgesplittert: -{0}
@@ -881,3 +866,29 @@ gg.ex.h3,Prüfbeispiel: Stark abgenutzt
 gg.ex.h4,Prüfbeispiel: Leicht gebraucht
 gg.ex.h5,Prüfbeispiel: Neu
 lbl.price,Etikettenpreis: {0}
+lbl.row.count,Lüfterzahl
+lbl.row.pin,Stromstecker
+lbl.count.1,1 Lüfter
+lbl.count.2,2 Lüfter
+lbl.count.3,3 Lüfter
+lbl.pin.0,6-Pin
+lbl.pin.1,8-Pin
+lbl.pin.2,2x 8-Pin
+gg.p1.body,"Grafikkarten sind das Herzstück jeder Mining-Anlage und die am häufigsten gefälschte Ware auf dem Gebrauchtmarkt.\nOb eine Karte echt ist, zeigen vier Merkmale: Lüfterzahl, Stromstecker, Aufdruck auf der Rückseite und Seriennummer. Nur eine Karte, bei der alle vier zum angegebenen Modell passen, ist echt; jede einzelne Abweichung bedeutet eine Fälschung.\nDer Wert einer Karte hängt vom Modell des echten Chips und von ihrem Zustand ab, und jede Gebrauchsspur senkt den Preis.\n\nDieser Leitfaden vermittelt das gesamte Wissen, das zur Begutachtung einer Grafikkarte nötig ist."
+gg.p2.h,Kartenmodelle
+gg.p2.body,Das Modell bestimmt Lüfterzahl und Stromstecker. Eine Fälschung ist ein Chip niedrigeren Modells in der Hülle eines höheren; Leistung und Wert richten sich nach dem echten Chip darin.
+gg.tier.0,"RTX 60 / RX 70: 6-Pin, 1 Lüfter"
+gg.tier.1,"RTX 70 / RX 80: 8-Pin, 2 Lüfter"
+gg.tier.2,"RTX 80 / RX 800: 8-Pin, 3 Lüfter"
+gg.tier.3,"RTX 90 / RX 900: 2x 8-Pin, 3 Lüfter"
+gg.count.h,Lüfterzahl
+gg.count.body,"Das Modell bestimmt die Lüfterzahl: einen Lüfter bei RTX 60 und RX 70, zwei bei RTX 70 und RX 80, drei bei RTX 80, RTX 90, RX 800 und RX 900.\nStimmt die Lüfterzahl nicht mit dem angegebenen Modell überein, handelt es sich um eine Fälschung."
+gg.pin.h,Stromstecker
+gg.pin.body,"Auch der Stromstecker richtet sich nach dem Modell: 6-Pin bei RTX 60 und RX 70, 8-Pin bei RTX 70, RTX 80, RX 80 und RX 800, 2x 8-Pin bei RTX 90 und RX 900.\nStimmt der Stromstecker nicht mit dem angegebenen Modell überein, handelt es sich um eine Fälschung."
+gg.serial.body,"Die Seriennummer steht auf einem Aufkleber auf der Rückseite: Präfix, Modellcode, Bindestrich, zweistelliger Werkscode, Bindestrich und vierstellige laufende Nummer, zum Beispiel PB2-21-6251."
+gg.serial.rule,"Die Modellcodes 1 bis 4 stehen für RTX 60 / RX 70, RTX 70 / RX 80, RTX 80 / RX 800 und RTX 90 / RX 900.\nEin Modellcode, der nicht zum Modell passt (der Aufkleber gehört zum ursprünglichen Chip), oder ein ungültiger Werkscode bzw. eine falsche Länge (nachträglich aufgeklebt) bedeutet eine Fälschung. Der Werkscode dient nur der Echtheitsprüfung und beeinflusst den Preis nicht."
+gg.print.note,"Echt ist eine Karte nur, wenn Lüfterzahl, Stromstecker, Aufdruck und Seriennummer alle zum Modell passen. Eine Fälschung weicht in mindestens einem Punkt ab, kann die übrigen aber korrekt nachahmen; deshalb muss jeder Punkt geprüft werden."
+gg.cond.h,Lüfterblätter und Kontakte
+gg.point.body,"Mit der Lupe prüfen; in der Beschriftungsleiste steht rechts in jeder Zeile „Beanstanden“. Wird ein verschwiegenes Problem beanstandet, wechselt die Zeile zum tatsächlichen Zustand und der Preis sinkt um die Differenz; wird etwas Zutreffendes beanstandet, weist die Gegenseite es zurück und der Ruf leidet.\nStimmt Lüfterzahl, Stromstecker, Aufdruck oder Seriennummer nicht mit dem Modell überein, wird sie beanstandet: Die Karte gilt dann als Fälschung, das Modell wechselt zum echten Chip und der Preis wird für diesen Chip neu berechnet.\n\nKarten von Kunden der Gutachtergilde funktionieren genauso: Nach dem Beanstanden ändert sich die Schätzung, bis der richtige Wert gemeldet wird."
+gg.ex.serial,Seriennummer: {0}
+gg.ex.h,"Beispiel: abgesplittertes Lüfterblatt, matte Kontakte, fehlendes Siegel"
@@ -820,17 +820,9 @@ settings.risk_scale_desc,"Multiplies the chance of scams, rug pulls, wallet pois
 settings.mining_scale,Mining reward multiplier
 settings.mining_scale_desc,Multiplies the block reward paid to mining rigs. Applies to all saves.
 gg.header,Station Trade Commission
-gg.p1.body,"Graphics cards are the core of every mining rig, and the goods most often counterfeited on the used market.\nA card's value depends on the model of the chip inside and its health, and every sign of wear lowers the price.\n\nThis guide provides all the knowledge needed to appraise a graphics card."
 gg.p1.cap,Graphics card
 gg.p1.makers,"There are two common manufacturers on the Station:\n\n      - Probidia (""PB"")\n      - PMD (""MD"")"
 gg.p1.note,"Whoever made it, a card's value depends only on the list price of the real chip and its health: at full health it equals the list price, at zero health only {CardValueFloor:%} is left."
-gg.p2.h,Card Tiers
-gg.p2.body,"The tier sets the power connector and the fan count. The model is only a display name; the real tier shows on the hardware.\nA counterfeit is a low-tier chip in a high-tier shell, and its performance and value follow the chip inside."
-gg.tier.0,"Entry (6-pin, one fan)"
-gg.tier.1,"Mid (8-pin, two fans)"
-gg.tier.2,"High (8-pin, three fans)"
-gg.tier.3,"Flagship (dual 8-pin, three fans)"
-gg.p2.models,"Probidia: RTX 60 / 70 / 80 / 90\nPMD: RX 70 / 80 / 800 / 900\nThe models map to entry, mid, high and flagship in order."
 gg.fan.h,Fan Blades
 gg.fan.0,Clean (price unchanged)
 gg.fan.1,Dusty (-{CardFanDust:%})
@@ -847,21 +839,14 @@ gg.seal.0,Intact (price unchanged)
 gg.seal.2,Missing (-{CardSealMissing:%})
 gg.wear.note,"Fan blades, contacts and bracket get worse with the nightly wear and only ever get worse; the seal is fixed. Condition also affects hashrate, wear and burnout chance."
 gg.serial.h,Serial Number
-gg.serial.body,"The serial number is on a sticker on the back, as prefix, tier code, hyphen, two-digit factory code, hyphen and four-digit sequence, for example PB2-21-6251."
 gg.serial.cap,Back of the card (serial sticker)
 gg.serial.pb,"Probidia (""PB"")\n      Valid factory codes: 11, 12, 21, 34, 47"
 gg.serial.md,"PMD (""MD"")\n      Valid factory codes: 13, 22, 35, 41, 58"
-gg.serial.rule,"Tier codes 1 to 4 run from entry to flagship.\nA tier code that does not match the model (the sticker belongs to the original chip), or an invalid factory code or length (a sticker added later), marks a counterfeit. The factory code only proves authenticity and does not change the price."
 gg.print.h,Back Print
 gg.print.0,Matches the model
 gg.print.1,Shows another model (counterfeit)
 gg.print.2,"Reprinted, crooked (counterfeit)"
-gg.print.note,"Connector and fan count come from the real chip, so a counterfeit never matches its stated model. The serial and the print can be made to look right, so no flaw does not prove a card is genuine."
-gg.seller.h,What Sellers Say
-gg.seller.body,"Used dealers come in three kinds:\n\n      - Honest: tells the truth.\n      - Middleman: states each item as fine with a {UsedMiddlemanHide:%} chance and adds {UsedMiddlemanMarkup:%} to the price; {UsedFakeMiddleman:%} of the cards are counterfeit.\n      - Scammer: states everything as fine, about {UsedFakeScammer:%} of the cards are counterfeit, and prices them as the stated model.\n\nThe seller's claim stands until you buy; after that the card shows its true condition."
 gg.point.h,Pointing Out
-gg.point.body,"Inspect with the magnifier; each row of the label bar has a Point out button on the right. Point out a hidden problem and that row switches to the true state and the price drops by the difference; point out something true and the other side refuses and your reputation suffers.\nPoint out the model and it reverts to the real chip, and the problems found are listed.\n\nCards brought by appraisal guild clients also carry a claim: pointing out problems changes the estimate until you report the correct value. When you show your own card to a customer, each hidden item has a {CustomerSpotChance:%} chance of being noticed."
-gg.ex.h,Appraisal Example
 gg.ex.card,"Example: {0}, health {1}%"
 gg.ex.base,Base value: +{0}
 gg.ex.fan,Chipped fan: -{0}
@@ -881,3 +866,29 @@ gg.ex.h3,Appraisal Example: Badly Worn
 gg.ex.h4,Appraisal Example: Lightly Used
 gg.ex.h5,Appraisal Example: Brand New
 lbl.price,Label price: {0}
+lbl.row.count,Fans
+lbl.row.pin,Power
+lbl.count.1,1 fan
+lbl.count.2,2 fans
+lbl.count.3,3 fans
+lbl.pin.0,6-pin
+lbl.pin.1,8-pin
+lbl.pin.2,Dual 8-pin
+gg.p1.body,"Graphics cards are the core of every mining rig, and the goods most often counterfeited on the used market.\nFour things show whether a card is genuine: fan count, power connector, back print and serial number. Only a card that matches its stated model on all four is genuine; any single mismatch means a counterfeit.\nA card's value depends on the model of the chip inside and its health, and every sign of wear lowers the price.\n\nThis guide provides all the knowledge needed to appraise a graphics card."
+gg.p2.h,Card Models
+gg.p2.body,"The model sets the fan count and the power connector. A counterfeit is a low-model chip in a high-model shell, and its performance and value follow the chip inside."
+gg.tier.0,"RTX 60 / RX 70: 6-pin, one fan"
+gg.tier.1,"RTX 70 / RX 80: 8-pin, two fans"
+gg.tier.2,"RTX 80 / RX 800: 8-pin, three fans"
+gg.tier.3,"RTX 90 / RX 900: dual 8-pin, three fans"
+gg.count.h,Fan Count
+gg.count.body,"The model sets the fan count: one fan on the RTX 60 and RX 70, two on the RTX 70 and RX 80, three on the RTX 80, RTX 90, RX 800 and RX 900.\nA fan count that does not match the stated model marks a counterfeit."
+gg.pin.h,Power Connector
+gg.pin.body,"The model also sets the power connector: 6-pin on the RTX 60 and RX 70, 8-pin on the RTX 70, RTX 80, RX 80 and RX 800, dual 8-pin on the RTX 90 and RX 900.\nA power connector that does not match the stated model marks a counterfeit."
+gg.serial.body,"The serial number is on a sticker on the back, as prefix, model code, hyphen, two-digit factory code, hyphen and four-digit sequence, for example PB2-21-6251."
+gg.serial.rule,"Model codes 1 to 4 stand for RTX 60 / RX 70, RTX 70 / RX 80, RTX 80 / RX 800 and RTX 90 / RX 900.\nA model code that does not match the model (the sticker belongs to the original chip), or an invalid factory code or length (a sticker added later), marks a counterfeit. The factory code only proves authenticity and does not change the price."
+gg.print.note,"A card is genuine only if fan count, power connector, print and serial number all match. A counterfeit fails at least one, but may get the others right, so check every one."
+gg.cond.h,Fan Blades and Contacts
+gg.point.body,"Inspect with the magnifier; each row of the label bar has a Point out button on the right. Point out a hidden problem and that row switches to the true state and the price drops by the difference; point out something true and the other side refuses and your reputation suffers.\nIf the fan count, power connector, print or serial number does not match, point it out: the card is then ruled a counterfeit, the model reverts to the real chip, and the price is recalculated for that chip.\n\nCards brought by appraisal guild clients work the same way: pointing out problems changes the estimate until you report the correct value."
+gg.ex.serial,Serial number: {0}
+gg.ex.h,"Appraisal Example: Chipped Fan, Dull Contacts, Missing Seal"
@@ -109,7 +109,7 @@ lbl.bracket.0,Intacto
 lbl.bracket.1,Rayado
 lbl.serial.0,Válido
 lbl.serial.1,Código de fábrica o longitud inválidos
-lbl.serial.2,Código de gama no coincide
+lbl.serial.2,Código de modelo no coincide
 lbl.seal.0,Intacto
 lbl.seal.2,Ausente
 lbl.tier.0,Entrada
@@ -820,17 +820,9 @@ settings.risk_scale_desc,"Multiplica la probabilidad de estafas, rug pulls, enve
 settings.mining_scale,Multiplicador de recompensa de minería
 settings.mining_scale_desc,Multiplica la recompensa de bloque que reciben los equipos de minería. Se aplica a todas las partidas.
 gg.header,Registro Mercantil de la estación
-gg.p1.body,Las tarjetas gráficas son el núcleo de toda plataforma de minería y la mercancía que más se falsifica en el mercado de segunda mano.\nEl valor de una tarjeta depende del modelo del chip real y de su salud; cada señal de desgaste reduce el precio.\n\nEsta guía reúne todos los conocimientos necesarios para tasar una tarjeta gráfica.
 gg.p1.cap,Tarjeta gráfica
 gg.p1.makers,"En la estación hay dos fabricantes habituales:\n\n      - Probidia (""PB"")\n      - PMD (""MD"")"
 gg.p1.note,"Sea cual sea el fabricante, el valor de una tarjeta depende solo del precio de lista del chip real y de su salud: con salud completa equivale al precio de lista, con salud 0 solo queda el {CardValueFloor:%}."
-gg.p2.h,Gamas de tarjeta
-gg.p2.body,La gama determina el conector de alimentación y el número de ventiladores. El modelo es solo un nombre mostrado; la gama real se ve en el hardware.\nUna falsificación es un chip de gama baja dentro de una carcasa de gama alta; su rendimiento y su valor siguen al chip real.
-gg.tier.0,"Entrada (6 pines, 1 vent.)"
-gg.tier.1,"Media (8 pines, 2 vent.)"
-gg.tier.2,"Alta (8 pines, 3 vent.)"
-gg.tier.3,"Insignia (2×8 pines, 3 vent.)"
-gg.p2.models,"Probidia: RTX 60 / 70 / 80 / 90\nPMD: RX 70 / 80 / 800 / 900\nLos modelos corresponden, en orden, a entrada, media, alta e insignia."
 gg.fan.h,Aspas
 gg.fan.0,Limpias (precio igual)
 gg.fan.1,Con polvo (-{CardFanDust:%})
@@ -847,21 +839,14 @@ gg.seal.0,Intacto (precio igual)
 gg.seal.2,Ausente (-{CardSealMissing:%})
 gg.wear.note,"Las aspas, los contactos y el soporte empeoran con el desgaste de cada noche y solo pueden ir a peor; el sello es una característica fija. La condición también afecta a la tasa de hash, al desgaste y a la probabilidad de quemarse."
 gg.serial.h,Número de serie
-gg.serial.body,"El número de serie está en una pegatina en el reverso, con el formato: prefijo, código de gama, guion, código de fábrica de dos dígitos, guion y número correlativo de cuatro dígitos, por ejemplo PB2-21-6251."
 gg.serial.cap,Reverso (pegatina de serie)
 gg.serial.pb,"Probidia (""PB"")\n      Códigos de fábrica válidos: 11, 12, 21, 34, 47"
 gg.serial.md,"PMD (""MD"")\n      Códigos de fábrica válidos: 13, 22, 35, 41, 58"
-gg.serial.rule,"Los códigos de gama 1 a 4 van de entrada a insignia.\nUn código de gama que no coincide con el modelo (la pegatina es la del chip original), o un código de fábrica o una longitud inválidos (pegatina añadida después), indican una falsificación. El código de fábrica solo sirve para comprobar la autenticidad y no cambia el precio."
 gg.print.h,Serigrafía dorso
 gg.print.0,Coincide con el modelo
 gg.print.1,Otro modelo (falsificación)
 gg.print.2,"Reimpreso, torcido (falsa)"
-gg.print.note,"El conector y el número de ventiladores vienen del chip real, por lo que una falsificación nunca coincide con el modelo indicado. El número de serie y la serigrafía pueden estar bien hechos; que no haya defectos no prueba que la tarjeta sea auténtica."
-gg.seller.h,Declaración
-gg.seller.body,"Los camellos de segunda mano son de tres tipos:\n\n      - Honrado: dice la verdad.\n      - Intermediario: declara cada punto como correcto con una probabilidad del {UsedMiddlemanHide:%} y añade un {UsedMiddlemanMarkup:%} al precio; el {UsedFakeMiddleman:%} de las tarjetas son falsificaciones.\n      - Estafador: declara todo como correcto, cerca del {UsedFakeScammer:%} de las tarjetas son falsificaciones, y las cobra al precio del modelo indicado.\n\nHasta la compra rige lo que dice el vendedor; después, la tarjeta muestra su condición real."
 gg.point.h,Señalar
-gg.point.body,"Se inspecciona con la lupa; a la derecha de cada fila de la barra de etiquetas aparece ""Señalar"". Al señalar un problema oculto, la fila pasa al estado real y el precio baja la diferencia; al señalar algo cierto, el vendedor lo rechaza y la reputación baja.\nAl señalar el modelo, este vuelve al chip real y se listan los problemas encontrados.\n\nLas tarjetas de los clientes del gremio de tasadores también traen una declaración: señalar problemas cambia la estimación hasta que se indica el valor correcto. Al mostrar una tarjeta propia a un cliente, cada punto oculto tiene una probabilidad del {CustomerSpotChance:%} de ser notado."
-gg.ex.h,Ejemplo práctico
 gg.ex.card,"Ejemplo: {0}, salud {1}%"
 gg.ex.base,Valor base: +{0}
 gg.ex.fan,Aspa mellada: -{0}
@@ -881,3 +866,29 @@ gg.ex.h3,Ejemplo práctico: muy desgastada
 gg.ex.h4,Ejemplo práctico: poco uso
 gg.ex.h5,Ejemplo práctico: nueva
 lbl.price,Precio de etiqueta: {0}
+lbl.row.count,Ventiladores
+lbl.row.pin,Alimentación
+lbl.count.1,1 ventilador
+lbl.count.2,2 ventiladores
+lbl.count.3,3 ventiladores
+lbl.pin.0,6 pines
+lbl.pin.1,8 pines
+lbl.pin.2,2 × 8 pines
+gg.p1.body,"Las tarjetas gráficas son el componente central de toda plataforma de minería y la mercancía más falsificada en el mercado de segunda mano.\nCuatro puntos indican si una tarjeta es auténtica: número de ventiladores, conector de alimentación, serigrafía trasera y número de serie. Solo es auténtica la tarjeta que coincide con su modelo declarado en los cuatro; una sola discrepancia supone una falsificación.\nEl valor de una tarjeta depende del modelo del chip real y de su estado, y cada señal de desgaste reduce el precio.\n\nEsta guía reúne todos los conocimientos necesarios para tasar una tarjeta gráfica."
+gg.p2.h,Modelos de tarjeta
+gg.p2.body,El modelo determina el número de ventiladores y el conector de alimentación. Una falsificación es un chip de modelo inferior dentro de la carcasa de un modelo superior; su rendimiento y su valor son los del chip real.
+gg.tier.0,"RTX 60 / RX 70: 6 pines, 1 vent."
+gg.tier.1,"RTX 70 / RX 80: 8 pines, 2 vent."
+gg.tier.2,"RTX 80 / RX 800: 8 pines, 3 vent."
+gg.tier.3,"RTX 90 / RX 900: 2×8 pines, 3 vent."
+gg.count.h,Número de ventiladores
+gg.count.body,"El modelo determina el número de ventiladores: uno en las RTX 60 y RX 70, dos en las RTX 70 y RX 80, tres en las RTX 80, RTX 90, RX 800 y RX 900.\nUn número de ventiladores que no coincide con el modelo declarado indica una falsificación."
+gg.pin.h,Conector de alimentación
+gg.pin.body,"El conector de alimentación también lo determina el modelo: 6 pines en las RTX 60 y RX 70, 8 pines en las RTX 70, RTX 80, RX 80 y RX 800, 2 × 8 pines en las RTX 90 y RX 900.\nUn conector de alimentación que no coincide con el modelo declarado indica una falsificación."
+gg.serial.body,"El número de serie va en una pegatina en el reverso, con este formato: prefijo, código de modelo, guion, código de fábrica de dos dígitos, guion y número correlativo de cuatro dígitos, por ejemplo PB2-21-6251."
+gg.serial.rule,"Los códigos de modelo 1 a 4 corresponden a RTX 60 / RX 70, RTX 70 / RX 80, RTX 80 / RX 800 y RTX 90 / RX 900.\nUn código de modelo que no coincide con el modelo (la pegatina es del chip original), o un código de fábrica o una longitud inválidos (pegatina añadida después), indica una falsificación. El código de fábrica solo sirve para comprobar la autenticidad y no afecta al precio."
+gg.print.note,"Una tarjeta solo es auténtica si el número de ventiladores, el conector de alimentación, la serigrafía y el número de serie coinciden todos con el modelo. Una falsificación falla al menos en uno, pero puede imitar bien los demás; por eso hay que comprobar cada punto."
+gg.cond.h,Aspas y contactos
+gg.point.body,"Se inspecciona con la lupa; a la derecha de cada fila de la barra de etiquetas está «Señalar». Al señalar un problema oculto, la fila pasa al estado real y el precio baja la diferencia; al señalar algo cierto, la otra parte lo rechaza y la reputación se resiente.\nSi el número de ventiladores, el conector de alimentación, la serigrafía o el número de serie no coincide con el modelo, se señala: la tarjeta queda declarada falsificación, el modelo vuelve al chip real y el precio se recalcula para ese chip.\n\nLas tarjetas que traen los clientes del gremio de tasadores funcionan igual: al señalar los problemas cambia la estimación, hasta que se indica el valor correcto."
+gg.ex.serial,Número de serie: {0}
+gg.ex.h,"Ejemplo de tasación: aspa mellada, contactos opacos, sello ausente"
@@ -109,7 +109,7 @@ lbl.bracket.0,Intacte
 lbl.bracket.1,Rayée
 lbl.serial.0,Valide
 lbl.serial.1,Code usine ou longueur incorrects
-lbl.serial.2,Code de gamme non correspondant
+lbl.serial.2,Code de modèle non correspondant
 lbl.seal.0,Intact
 lbl.seal.2,Manquant
 lbl.tier.0,Entrée de gamme
@@ -820,17 +820,9 @@ settings.risk_scale_desc,"Multiplie la probabilité d'arnaques, de rug pulls, d'
 settings.mining_scale,Multiplicateur de gains de minage
 settings.mining_scale_desc,Multiplie la récompense de bloc versée aux machines de minage. S'applique à toutes les sauvegardes.
 gg.header,Comité de commerce
-gg.p1.body,Les cartes graphiques sont le cœur de toute plateforme de minage et la marchandise la plus souvent contrefaite sur le marché de l'occasion.\nLa valeur d'une carte dépend du modèle de la puce réelle et de son état de santé ; chaque trace d'usure fait baisser le prix.\n\nCe guide présente toutes les connaissances nécessaires pour expertiser une carte graphique.
 gg.p1.cap,Carte graphique
 gg.p1.makers,Deux fabricants courants sont présents sur la station :\n\n      - Probidia (« PB »)\n      - PMD (« MD »)
 gg.p1.note,"Quel que soit le fabricant, la valeur d'une carte dépend uniquement du prix catalogue de la puce réelle et de sa santé : à pleine santé elle égale le prix catalogue, à santé 0 il n'en reste que {CardValueFloor:%}."
-gg.p2.h,Gammes de cartes
-gg.p2.body,La gamme détermine le connecteur d'alimentation et le nombre de ventilateurs. Le modèle n'est qu'un nom affiché ; la vraie gamme se lit sur le matériel.\nUne contrefaçon est une puce de gamme basse dans un boîtier de gamme haute ; ses performances et sa valeur suivent la puce réelle.
-gg.tier.0,"Entrée de gamme (6 br., 1 v.)"
-gg.tier.1,"Milieu de gamme (8 br., 2 v.)"
-gg.tier.2,"Haut de gamme (8 br., 3 v.)"
-gg.tier.3,"Très haut de gamme (2×8, 3 v.)"
-gg.p2.models,"Probidia : RTX 60 / 70 / 80 / 90\nPMD : RX 70 / 80 / 800 / 900\nLes modèles correspondent dans l'ordre à entrée de gamme, milieu de gamme, haut de gamme et très haut de gamme."
 gg.fan.h,Pales
 gg.fan.0,Propres (prix inchangé)
 gg.fan.1,Poussiéreuses (-{CardFanDust:%})
@@ -847,21 +839,14 @@ gg.seal.0,Intact (prix inchangé)
 gg.seal.2,Manquant (-{CardSealMissing:%})
 gg.wear.note,"Les pales, les contacts et l'équerre se dégradent avec l'usure de chaque nuit et ne font qu'empirer ; le scellé est une caractéristique fixe. L'état influe aussi sur le taux de hachage, l'usure et la probabilité de griller."
 gg.serial.h,N° de série
-gg.serial.body,"Le numéro de série figure sur un autocollant au dos de la carte, sous la forme : préfixe, code de gamme, tiret, code usine à deux chiffres, tiret, numéro d'ordre à quatre chiffres, par exemple PB2-21-6251."
 gg.serial.cap,Dos de la carte (autocollant)
 gg.serial.pb,"Probidia (« PB »)\n      Codes usine valides : 11, 12, 21, 34, 47"
 gg.serial.md,"PMD (« MD »)\n      Codes usine valides : 13, 22, 35, 41, 58"
-gg.serial.rule,"Les codes de gamme 1 à 4 vont de l'entrée de gamme au très haut de gamme.\nUn code de gamme qui ne correspond pas au modèle (l'autocollant est celui de la puce d'origine), ou un code usine ou une longueur invalide (autocollant ajouté après coup), indique une contrefaçon. Le code usine ne sert qu'à prouver l'authenticité et ne change pas le prix."
 gg.print.h,Sérigraphie dos
 gg.print.0,Conforme au modèle
 gg.print.1,Autre modèle (contrefaçon)
 gg.print.2,"Réimprimé, de travers (faux)"
-gg.print.note,Le connecteur et le nombre de ventilateurs viennent de la puce réelle : une contrefaçon ne correspond donc jamais au modèle annoncé. Le numéro de série et la sérigraphie peuvent être soignés ; l'absence de défaut ne prouve donc pas qu'une carte est authentique.
-gg.seller.h,Dires du vendeur
-gg.seller.body,"Les dealeurs d'occasion sont de trois types :\n\n      - Honnête : dit la vérité.\n      - Intermédiaire : déclare chaque point sans défaut avec une probabilité de {UsedMiddlemanHide:%} et ajoute {UsedMiddlemanMarkup:%} au prix ; {UsedFakeMiddleman:%} des cartes sont des contrefaçons.\n      - Arnaqueur : déclare tout sans défaut, environ {UsedFakeScammer:%} des cartes sont des contrefaçons, et les facture au prix du modèle annoncé.\n\nJusqu'à l'achat, les dires du vendeur font foi ; ensuite, la carte montre son véritable état."
 gg.point.h,Signaler
-gg.point.body,"Inspecter à la loupe ; à droite de chaque ligne de la barre d'étiquettes se trouve « Signaler ». En signalant un défaut dissimulé, la ligne passe à l'état réel et le prix baisse de la différence ; en signalant un point exact, le vendeur refuse et la réputation baisse.\nEn signalant le modèle, il revient à la puce réelle et les problèmes trouvés sont listés.\n\nLes cartes apportées par les clients de la guilde d'expertise portent aussi une déclaration : les signalements modifient l'estimation, jusqu'à ce que la valeur correcte soit annoncée. Lorsqu'on présente sa propre carte à un client, chaque point dissimulé a une probabilité de {CustomerSpotChance:%} d'être remarqué."
-gg.ex.h,Exemple
 gg.ex.card,"Exemple : {0}, santé {1}%"
 gg.ex.base,Valeur de base : +{0}
 gg.ex.fan,Pale ébréchée : -{0}
@@ -881,3 +866,29 @@ gg.ex.h3,Exemple : très usée
 gg.ex.h4,Exemple : peu utilisée
 gg.ex.h5,Exemple : neuve
 lbl.price,Prix affiché : {0}
+lbl.row.count,Ventilateurs
+lbl.row.pin,Alimentation
+lbl.count.1,1 ventilateur
+lbl.count.2,2 ventilateurs
+lbl.count.3,3 ventilateurs
+lbl.pin.0,6 broches
+lbl.pin.1,8 broches
+lbl.pin.2,2 × 8 broches
+gg.p1.body,"Les cartes graphiques sont l'élément central de toute plateforme de minage et la marchandise la plus souvent contrefaite sur le marché de l'occasion.\nQuatre points permettent de juger si une carte est authentique : nombre de ventilateurs, connecteur d'alimentation, sérigraphie au dos et numéro de série. Seule une carte conforme à son modèle annoncé sur les quatre points est authentique ; un seul écart suffit pour une contrefaçon.\nLa valeur d'une carte dépend du modèle de la puce réelle et de son état, et chaque trace d'usure fait baisser le prix.\n\nCe guide fournit toutes les connaissances nécessaires pour expertiser une carte graphique."
+gg.p2.h,Modèles de carte
+gg.p2.body,Le modèle détermine le nombre de ventilateurs et le connecteur d'alimentation. Une contrefaçon est une puce de modèle inférieur dans le boîtier d'un modèle supérieur ; ses performances et sa valeur sont celles de la puce réelle.
+gg.tier.0,"RTX 60 / RX 70 : 6 broches, 1 vent."
+gg.tier.1,"RTX 70 / RX 80 : 8 broches, 2 vent."
+gg.tier.2,"RTX 80 / RX 800 : 8 broches, 3 vent."
+gg.tier.3,"RTX 90 / RX 900 : 2 × 8 br., 3 vent."
+gg.count.h,Nombre de ventilateurs
+gg.count.body,"Le modèle détermine le nombre de ventilateurs : un ventilateur pour les RTX 60 et RX 70, deux pour les RTX 70 et RX 80, trois pour les RTX 80, RTX 90, RX 800 et RX 900.\nUn nombre de ventilateurs qui ne correspond pas au modèle annoncé indique une contrefaçon."
+gg.pin.h,Connecteur d'alimentation
+gg.pin.body,"Le connecteur d'alimentation est lui aussi déterminé par le modèle : 6 broches pour les RTX 60 et RX 70, 8 broches pour les RTX 70, RTX 80, RX 80 et RX 800, 2 × 8 broches pour les RTX 90 et RX 900.\nUn connecteur d'alimentation qui ne correspond pas au modèle annoncé indique une contrefaçon."
+gg.serial.body,"Le numéro de série figure sur un autocollant au dos, sous la forme : préfixe, code de modèle, tiret, code usine à deux chiffres, tiret et numéro d'ordre à quatre chiffres, par exemple PB2-21-6251."
+gg.serial.rule,"Les codes de modèle 1 à 4 correspondent à RTX 60 / RX 70, RTX 70 / RX 80, RTX 80 / RX 800 et RTX 90 / RX 900.\nUn code de modèle qui ne correspond pas au modèle (l'autocollant provient de la puce d'origine), ou un code usine ou une longueur non valides (autocollant ajouté après coup), indique une contrefaçon. Le code usine ne sert qu'à vérifier l'authenticité et n'influence pas le prix."
+gg.print.note,"Une carte n'est authentique que si le nombre de ventilateurs, le connecteur d'alimentation, la sérigraphie et le numéro de série correspondent tous au modèle. Une contrefaçon présente au moins un écart, mais peut imiter correctement les autres points ; chacun doit donc être vérifié."
+gg.cond.h,Pales et contacts
+gg.point.body,"S'inspecte à la loupe ; à droite de chaque ligne de la barre d'étiquettes se trouve « Signaler ». Signaler un défaut dissimulé fait passer la ligne à l'état réel et le prix baisse de la différence ; signaler un point exact est rejeté par l'autre partie et la réputation en pâtit.\nSi le nombre de ventilateurs, le connecteur d'alimentation, la sérigraphie ou le numéro de série ne correspond pas au modèle, le signaler : la carte est alors déclarée contrefaçon, le modèle revient à la puce réelle et le prix est recalculé pour cette puce.\n\nLes cartes apportées par les clients de la guilde d'expertise suivent la même règle : les signalements modifient l'estimation jusqu'à l'annonce de la valeur correcte."
+gg.ex.serial,N° de série : {0}
+gg.ex.h,"Exemple d'expertise : pale ébréchée, contacts ternes, scellé manquant"
@@ -109,7 +109,7 @@ lbl.bracket.0,良好
 lbl.bracket.1,キズあり
 lbl.serial.0,正常
 lbl.serial.1,工場コードまたは桁数異常
-lbl.serial.2,グレードコード不一致
+lbl.serial.2,型番コード不一致
 lbl.seal.0,無傷
 lbl.seal.2,欠損
 lbl.tier.0,エントリー
@@ -820,17 +820,9 @@ settings.risk_scale_desc,詐欺、ラグプル、ウォレットポイズニン
 settings.mining_scale,採掘報酬倍率
 settings.mining_scale_desc,採掘機器が受け取るブロック報酬にかかる倍率。すべてのセーブに適用されます。
 gg.header,ステーション取引委員会
-gg.p1.body,グラフィックボードはマイニングリグの中核部品であり、中古市場で最も偽造されやすい品でもある。\nボードの価値は、本物のチップの型番と耐久度で決まり、外観の傷みはすべて減額の対象となる。\n\n本ガイドは、グラフィックボードの鑑定に必要な知識をすべて示す。
 gg.p1.cap,グラフィックボード
 gg.p1.makers,ステーションには一般的なメーカーが2社ある。\n\n      - Probidia（「PB」）\n      - PMD（「MD」）
 gg.p1.note,メーカーを問わず、ボードの価値は本物のチップの型番定価と耐久度だけで決まる。耐久度が満タンなら定価と等しく、耐久度0では{CardValueFloor:%}だけが残る。
-gg.p2.h,ボードのグレード
-gg.p2.body,グレードによって電源コネクタとファンの数が決まる。型番は表示名にすぎず、本当のグレードは実物で判別する。\n偽造品は、低グレードのチップを高グレードの外装に収めたもので、性能と価値は中のチップに従う。
-gg.tier.0,エントリー（6ピン、ファン1基）
-gg.tier.1,ミドル（8ピン、ファン2基）
-gg.tier.2,ハイエンド（8ピン、ファン3基）
-gg.tier.3,フラッグシップ（2×8ピン、ファン3基）
-gg.p2.models,Probidia：RTX 60 / 70 / 80 / 90\nPMD：RX 70 / 80 / 800 / 900\n型番は順にエントリー、ミドル、ハイエンド、フラッグシップに対応する。
 gg.fan.h,ブレード
 gg.fan.0,良好（価格変わらず）
 gg.fan.1,埃あり（-{CardFanDust:%}）
@@ -847,21 +839,14 @@ gg.seal.0,無傷（価格変わらず）
 gg.seal.2,欠損（-{CardSealMissing:%}）
 gg.wear.note,ブレード、端子、ブラケットは毎晩の損耗で劣化し、悪化する一方である。封印シールは固定の特徴である。状態はハッシュレート、損耗、焼損確率にも影響する。
 gg.serial.h,シリアル番号
-gg.serial.body,シリアル番号はボード背面のシールに記され、接頭辞、グレードコード、ハイフン、2桁の工場コード、ハイフン、4桁の連番の順に並ぶ。例：PB2-21-6251。
 gg.serial.cap,背面（シリアルシール）
 gg.serial.pb,Probidia（「PB」）\n      正規の工場コード：11、12、21、34、47
 gg.serial.md,PMD（「MD」）\n      正規の工場コード：13、22、35、41、58
-gg.serial.rule,グレードコード1～4は、エントリーからフラッグシップに順に対応する。\nグレードコードが型番と一致しない場合（元のチップのシリアルが貼られている）、または工場コードや桁数が不正な場合（後から貼られたシール）は、偽造品である。工場コードは真偽の判定にのみ使い、価格には影響しない。
 gg.print.h,背面印字
 gg.print.0,型番一致
 gg.print.1,他型番の印字（偽造品）
 gg.print.2,再印字・傾き（偽造品）
-gg.print.note,電源コネクタとファンの数は本物のチップで決まるため、偽造品は表示された型番と必ず食い違う。シリアル番号と印字は精巧に作られている場合があり、欠陥がなくても本物とは限らない。
-gg.seller.h,売り手の申告
-gg.seller.body,中古ハードウェア取引人には3種類ある。\n\n      - 正直者：事実どおりに申告する。\n      - 仲介人：各項目を{UsedMiddlemanHide:%}の確率で問題なしと申告し、価格に{UsedMiddlemanMarkup:%}を上乗せする。カードの{UsedFakeMiddleman:%}は偽造品。\n      - 詐欺師：すべて問題なしと申告し、カードの約{UsedFakeScammer:%}は偽造品で、表示された型番の価格で売る。\n\n購入前は売り手の申告が有効で、購入後はボードが本来の状態に戻る。
 gg.point.h,指摘
-gg.point.body,ルーペで調べる。ラベル欄の各行の右側に「指摘する」がある。隠された問題を指摘すると、その行が本来の状態に変わり、価格は差額分だけ下がる。事実を指摘した場合、相手は認めず、評判が下がる。\n型番を指摘すると、型番が本物のチップに戻り、見つかった問題が一覧で示される。\n\n鑑定ギルドの客が持ち込むボードにも申告が付く。問題を指摘すると見積もりが変わり、最後に正しい価値を報告する。自分のボードを客に見せる場合、申告で隠した項目は、それぞれ{CustomerSpotChance:%}の確率で客に見抜かれる。
-gg.ex.h,鑑定例
 gg.ex.card,例：{0}、耐久度{1}%
 gg.ex.base,基礎価値：+{0}
 gg.ex.fan,ブレード欠け：-{0}
@@ -881,3 +866,29 @@ gg.ex.h3,鑑定例：状態不良
 gg.ex.h4,鑑定例：軽使用
 gg.ex.h5,鑑定例：新品
 lbl.price,表示価格：{0}
+lbl.row.count,ファン数
+lbl.row.pin,電源コネクタ
+lbl.count.1,ファン1基
+lbl.count.2,ファン2基
+lbl.count.3,ファン3基
+lbl.pin.0,6ピン
+lbl.pin.1,8ピン
+lbl.pin.2,8ピン×2
+gg.p1.body,グラフィックボードはマイニングリグの中核部品であり、中古市場で最も偽造されやすい商品である。\n正規品かどうかは、ファン数、電源コネクタ、背面印字、シリアル番号の4項目で判断する。4項目すべてが表示上の型番と一致するものだけが正規品であり、1つでも合わなければ偽造品である。\nボードの価値は実際のチップの型番と状態で決まり、外観の傷みはすべて減額の対象となる。\n\n本ガイドは、グラフィックボードの鑑定に必要な知識をすべて提供する。
+gg.p2.h,ボードの型番
+gg.p2.body,型番によってファン数と電源コネクタが決まる。偽造品は、低い型番のチップに高い型番の外装を被せたもので、性能と価値は内部の実際のチップに基づく。
+gg.tier.0,RTX 60 / RX 70：6ピン、ファン1基
+gg.tier.1,RTX 70 / RX 80：8ピン、ファン2基
+gg.tier.2,RTX 80 / RX 800：8ピン、ファン3基
+gg.tier.3,RTX 90 / RX 900：8ピン×2、ファン3基
+gg.count.h,ファン数
+gg.count.body,ファン数は型番で決まる。RTX 60とRX 70は1基、RTX 70とRX 80は2基、RTX 80、RTX 90、RX 800、RX 900は3基である。\n実物のファン数が表示上の型番と合わないものは偽造品である。
+gg.pin.h,電源コネクタ
+gg.pin.body,電源コネクタも型番で決まる。RTX 60とRX 70は6ピン、RTX 70、RTX 80、RX 80、RX 800は8ピン、RTX 90とRX 900は8ピン×2である。\n実物の電源コネクタが表示上の型番と合わないものは偽造品である。
+gg.serial.body,シリアル番号はボード背面のシールに記載され、書式は、プレフィックス、型番コード、ハイフン、2桁の工場コード、ハイフン、4桁の連番の順である。例：PB2-21-6251。
+gg.serial.rule,型番コードの1～4は、順にRTX 60 / RX 70、RTX 70 / RX 80、RTX 80 / RX 800、RTX 90 / RX 900に対応する。\n型番コードが型番と合わないもの（元のチップのシリアルが貼られている）、または工場コードや桁数が不正なもの（後から貼られたシール）は偽造品である。工場コードは真贋の判定にのみ使い、価格には影響しない。
+gg.print.note,正規品となるのは、ファン数、電源コネクタ、印字、シリアル番号の4項目がすべて型番と一致する場合のみである。偽造品は少なくとも1項目が合わないが、残りが正しく作られていることもあるため、各項目を確認する。
+gg.cond.h,ブレードと端子
+gg.point.body,拡大鏡で検分する。ラベルバーの各行の右側が「指摘する」である。隠された問題を指摘すると、その行が実際の状態に変わり、価格は差額分下がる。事実でないことを指摘すると、相手は認めず、信用が下がる。\nファン数、電源コネクタ、印字、シリアル番号のいずれかが型番と合わない場合は、それを指摘する。そのボードは偽造品と認定され、型番は実際のチップに戻り、価格は実際のチップで再計算される。\n\n鑑定ギルドの依頼人が持ち込むボードも同様で、問題を指摘すると見積もりが変わり、最終的に正しい価値を報告する。
+gg.ex.serial,シリアル番号：{0}
+gg.ex.h,鑑定例：ブレード欠け、端子のくすみ、封印シール欠損
@@ -109,7 +109,7 @@ lbl.bracket.0,Nienaruszony
 lbl.bracket.1,Porysowany
 lbl.serial.0,Prawidłowy
 lbl.serial.1,Zły kod fabryki lub zła długość
-lbl.serial.2,Kod segmentu nie pasuje
+lbl.serial.2,Kod modelu nie pasuje
 lbl.seal.0,Nienaruszona
 lbl.seal.2,Brak
 lbl.tier.0,Podstawowy
@@ -820,17 +820,9 @@ settings.risk_scale_desc,"Mnoży szanse na oszustwa, rug pulle, zatrucie portfel
 settings.mining_scale,Mnożnik wydobycia
 settings.mining_scale_desc,Mnoży nagrodę za blok wypłacaną koparkom. Dotyczy wszystkich zapisów.
 gg.header,Komisja Handlu Stacji
-gg.p1.body,"Karty graficzne to serce każdej koparki i towar, który na rynku wtórnym podrabia się najczęściej.\nWartość karty zależy od modelu prawdziwego chipa i jego kondycji; każdy ślad zużycia obniża cenę.\n\nTen przewodnik zawiera całą wiedzę potrzebną do oceny karty graficznej."
 gg.p1.cap,Karta graficzna
 gg.p1.makers,"Na stacji działa dwóch popularnych producentów:\n\n      - Probidia (""PB"")\n      - PMD (""MD"")"
 gg.p1.note,"Niezależnie od producenta wartość karty zależy tylko od ceny katalogowej prawdziwego chipa i jego kondycji: przy pełnej kondycji równa się cenie katalogowej, przy kondycji 0 zostaje tylko {CardValueFloor:%}."
-gg.p2.h,Segmenty kart
-gg.p2.body,Segment określa złącze zasilania i liczbę wentylatorów. Model to tylko wyświetlana nazwa; prawdziwy segment widać po sprzęcie.\nPodróbka to chip niskiego segmentu w obudowie wysokiego; jej wydajność i wartość wynikają z chipa w środku.
-gg.tier.0,"Podstawowy (6-pin, 1 went.)"
-gg.tier.1,"Średni (8-pin, 2 went.)"
-gg.tier.2,"Wysoki (8-pin, 3 went.)"
-gg.tier.3,"Flagowy (2×8-pin, 3 went.)"
-gg.p2.models,"Probidia: RTX 60 / 70 / 80 / 90\nPMD: RX 70 / 80 / 800 / 900\nModele odpowiadają kolejno segmentom: podstawowy, średni, wysoki i flagowy."
 gg.fan.h,Łopatki
 gg.fan.0,Czyste (cena bez zmian)
 gg.fan.1,Zakurzone (-{CardFanDust:%})
@@ -847,21 +839,14 @@ gg.seal.0,Nienaruszona (cena bez zmian)
 gg.seal.2,Brak (-{CardSealMissing:%})
 gg.wear.note,"Łopatki, styki i śledź pogarszają się przez nocne zużycie i mogą tylko się psuć; plomba jest cechą stałą. Stan wpływa też na moc obliczeniową, zużycie i szansę przepalenia."
 gg.serial.h,Numer seryjny
-gg.serial.body,"Numer seryjny znajduje się na naklejce z tyłu karty i ma postać: prefiks, kod segmentu, myślnik, dwucyfrowy kod fabryki, myślnik i czterocyfrowy numer kolejny, na przykład PB2-21-6251."
 gg.serial.cap,Tył karty (naklejka z numerem)
 gg.serial.pb,"Probidia (""PB"")\n      Prawidłowe kody fabryk: 11, 12, 21, 34, 47"
 gg.serial.md,"PMD (""MD"")\n      Prawidłowe kody fabryk: 13, 22, 35, 41, 58"
-gg.serial.rule,Kody segmentu od 1 do 4 oznaczają kolejno segmenty od podstawowego do flagowego.\nKod segmentu niezgodny z modelem (naklejka pochodzi od oryginalnego chipa) albo nieprawidłowy kod fabryki lub długość (naklejka dodana później) oznacza podróbkę. Kod fabryki służy tylko do sprawdzenia autentyczności i nie zmienia ceny.
 gg.print.h,Nadruk z tyłu
 gg.print.0,Zgodny z modelem
 gg.print.1,Inny model (podróbka)
 gg.print.2,"Przedruk, krzywy (podróbka)"
-gg.print.note,"Złącze zasilania i liczba wentylatorów wynikają z prawdziwego chipa, więc podróbka nigdy nie pasuje do podanego modelu. Numer seryjny i nadruk mogą być wykonane starannie, więc brak usterek nie dowodzi, że karta jest oryginalna."
-gg.seller.h,Deklaracja
-gg.seller.body,"Dilerzy używanego sprzętu dzielą się na trzy rodzaje:\n\n      - Uczciwy: mówi prawdę.\n      - Pośrednik: każdy punkt podaje jako sprawny z szansą {UsedMiddlemanHide:%} i dolicza {UsedMiddlemanMarkup:%} do ceny; {UsedFakeMiddleman:%} kart to podróbki.\n      - Oszust: wszystko podaje jako sprawne, około {UsedFakeScammer:%} kart to podróbki, a cenę podaje jak za wskazany model.\n\nDo zakupu obowiązuje deklaracja sprzedającego; po zakupie karta pokazuje prawdziwy stan."
 gg.point.h,Wskazywanie
-gg.point.body,"Kartę sprawdza się lupą; po prawej stronie każdego wiersza paska etykiet znajduje się ""Wskaż"". Po wskazaniu ukrytej wady wiersz zmienia się na stan faktyczny, a cena spada o różnicę; po wskazaniu rzeczy prawdziwej sprzedający nie przyznaje racji i spada reputacja.\nPo wskazaniu modelu wraca on do prawdziwego chipa, a wykryte problemy zostają wypisane.\n\nKarty klientów gildii rzeczoznawców również mają deklarację: wskazywanie problemów zmienia wycenę, aż zostanie podana prawidłowa wartość. Przy pokazywaniu klientowi własnej karty każdy ukryty punkt ma {CustomerSpotChance:%} szans na zauważenie."
-gg.ex.h,Przykład oceny
 gg.ex.card,"Przykład: {0}, kondycja {1}%"
 gg.ex.base,Wartość bazowa: +{0}
 gg.ex.fan,Wyszczerbiona łopatka: -{0}
@@ -881,3 +866,29 @@ gg.ex.h3,Przykład oceny: mocno zużyta
 gg.ex.h4,Przykład oceny: lekko używana
 gg.ex.h5,Przykład oceny: nowa
 lbl.price,Cena z etykiety: {0}
+lbl.row.count,Wentylatory
+lbl.row.pin,Zasilanie
+lbl.count.1,1 wentylator
+lbl.count.2,2 wentylatory
+lbl.count.3,3 wentylatory
+lbl.pin.0,6-pin
+lbl.pin.1,8-pin
+lbl.pin.2,2× 8-pin
+gg.p1.body,"Karty graficzne to podstawowy element każdej koparki i towar najczęściej podrabiany na rynku wtórnym.\nO autentyczności karty świadczą cztery cechy: liczba wentylatorów, złącze zasilania, nadruk z tyłu i numer seryjny. Autentyczna jest tylko karta zgodna z deklarowanym modelem pod każdym z tych czterech względów; jedna rozbieżność oznacza podróbkę.\nWartość karty zależy od modelu prawdziwego układu i jego kondycji, a każdy ślad zużycia obniża cenę.\n\nTen poradnik zawiera całą wiedzę potrzebną do wyceny karty graficznej."
+gg.p2.h,Modele kart
+gg.p2.body,Model określa liczbę wentylatorów i złącze zasilania. Podróbka to układ niższego modelu w obudowie wyższego; jej wydajność i wartość wynikają z prawdziwego układu w środku.
+gg.tier.0,"RTX 60 / RX 70: 6-pin, 1 went."
+gg.tier.1,"RTX 70 / RX 80: 8-pin, 2 went."
+gg.tier.2,"RTX 80 / RX 800: 8-pin, 3 went."
+gg.tier.3,"RTX 90 / RX 900: 2× 8-pin, 3 went."
+gg.count.h,Liczba wentylatorów
+gg.count.body,"Model określa liczbę wentylatorów: jeden w RTX 60 i RX 70, dwa w RTX 70 i RX 80, trzy w RTX 80, RTX 90, RX 800 i RX 900.\nLiczba wentylatorów niezgodna z deklarowanym modelem oznacza podróbkę."
+gg.pin.h,Złącze zasilania
+gg.pin.body,"Złącze zasilania również zależy od modelu: 6-pin w RTX 60 i RX 70, 8-pin w RTX 70, RTX 80, RX 80 i RX 800, 2× 8-pin w RTX 90 i RX 900.\nZłącze zasilania niezgodne z deklarowanym modelem oznacza podróbkę."
+gg.serial.body,"Numer seryjny znajduje się na naklejce z tyłu karty w formacie: prefiks, kod modelu, myślnik, dwucyfrowy kod fabryki, myślnik i czterocyfrowy numer kolejny, na przykład PB2-21-6251."
+gg.serial.rule,"Kody modelu od 1 do 4 odpowiadają kolejno RTX 60 / RX 70, RTX 70 / RX 80, RTX 80 / RX 800 i RTX 90 / RX 900.\nKod modelu niezgodny z modelem (naklejka pochodzi z oryginalnego układu) albo nieprawidłowy kod fabryki lub długość (naklejka dodana później) oznacza podróbkę. Kod fabryki służy wyłącznie do sprawdzania autentyczności i nie wpływa na cenę."
+gg.print.note,"Karta jest autentyczna tylko wtedy, gdy liczba wentylatorów, złącze zasilania, nadruk i numer seryjny są zgodne z modelem. Podróbka ma rozbieżność w co najmniej jednym punkcie, ale pozostałe może imitować poprawnie, dlatego trzeba sprawdzić każdy z nich."
+gg.cond.h,Łopatki i styki
+gg.point.body,"Kartę sprawdza się lupą; po prawej stronie każdego wiersza paska etykiet znajduje się „Wskaż”. Wskazanie ukrytego problemu zmienia wiersz na stan rzeczywisty, a cena spada o różnicę; wskazanie czegoś prawdziwego druga strona odrzuca, a reputacja na tym traci.\nJeśli liczba wentylatorów, złącze zasilania, nadruk lub numer seryjny nie zgadza się z modelem, należy to wskazać: karta zostaje uznana za podróbkę, model wraca do prawdziwego układu, a cena jest liczona od nowa dla tego układu.\n\nKarty przynoszone przez klientów gildii rzeczoznawców działają tak samo: po wskazaniu problemów wycena się zmienia, aż zostanie podana prawidłowa wartość."
+gg.ex.serial,Numer seryjny: {0}
+gg.ex.h,"Przykład wyceny: wyszczerbiona łopatka, zmatowiałe styki, brak plomby"
@@ -109,7 +109,7 @@ lbl.bracket.0,Целая
 lbl.bracket.1,С царапинами
 lbl.serial.0,Корректный
 lbl.serial.1,Неверный код завода или длина
-lbl.serial.2,Код уровня не соответствует модели
+lbl.serial.2,Код модели не соответствует
 lbl.seal.0,Целая
 lbl.seal.2,Отсутствует
 lbl.tier.0,Начальный
@@ -820,17 +820,9 @@ settings.risk_scale_desc,"Умножает вероятность мошенни
 settings.mining_scale,Множитель добычи
 settings.mining_scale_desc,"Умножает награду за блок, получаемую майнинг-фермами. Действует для всех сохранений."
 gg.header,Торговая комиссия станции
-gg.p1.body,"Видеокарты — основа любой майнинг-фермы и товар, который на вторичном рынке подделывают чаще всего.\nСтоимость карты зависит от модели настоящего чипа и его прочности; каждый след износа снижает цену.\n\nВ этом руководстве собраны все знания, необходимые для оценки видеокарты."
 gg.p1.cap,Видеокарта
 gg.p1.makers,На станции распространены два производителя:\n\n      - Probidia («PB»)\n      - PMD («MD»)
 gg.p1.note,"Независимо от производителя стоимость карты зависит только от прайсовой цены настоящего чипа и его прочности: при полной прочности она равна прайсовой цене, при прочности 0 остаётся лишь {CardValueFloor:%}."
-gg.p2.h,Классы карт
-gg.p2.body,Класс определяет разъём питания и число вентиляторов. Модель — лишь отображаемое название; настоящий класс виден по железу.\nПодделка — чип низкого класса в корпусе высокого; её производительность и стоимость определяет чип внутри.
-gg.tier.0,"Начальный (6 pin, 1 вент.)"
-gg.tier.1,"Средний (8 pin, 2 вент.)"
-gg.tier.2,"Высокий (8 pin, 3 вент.)"
-gg.tier.3,"Флагман (2×8 pin, 3 вент.)"
-gg.p2.models,"Probidia: RTX 60 / 70 / 80 / 90\nPMD: RX 70 / 80 / 800 / 900\nМодели по порядку соответствуют классам: начальный, средний, высокий и флагман."
 gg.fan.h,Лопасти
 gg.fan.0,Чистые (цена прежняя)
 gg.fan.1,В пыли (-{CardFanDust:%})
@@ -847,21 +839,14 @@ gg.seal.0,Целая (цена прежняя)
 gg.seal.2,Отсутствует (-{CardSealMissing:%})
 gg.wear.note,"Лопасти, контакты и планка ухудшаются от ночного износа и только портятся со временем; пломба — постоянный признак. Состояние также влияет на хешрейт, износ и вероятность сгореть."
 gg.serial.h,Серийный номер
-gg.serial.body,"Серийный номер указан на наклейке на обратной стороне в формате: префикс, код класса, дефис, двузначный код завода, дефис, четырёхзначный порядковый номер, например PB2-21-6251."
 gg.serial.cap,Обратная сторона (наклейка)
 gg.serial.pb,"Probidia («PB»)\n      Допустимые коды заводов: 11, 12, 21, 34, 47"
 gg.serial.md,"PMD («MD»)\n      Допустимые коды заводов: 13, 22, 35, 41, 58"
-gg.serial.rule,"Коды класса от 1 до 4 соответствуют классам от начального до флагмана.\nКод класса, не совпадающий с моделью (наклейка от исходного чипа), либо недопустимый код завода или длина (наклейка наклеена позже) означают подделку. Код завода служит только для проверки подлинности и не влияет на цену."
 gg.print.h,Маркировка сзади
 gg.print.0,Соответствует модели
 gg.print.1,Другая модель (подделка)
 gg.print.2,"Перепечатано, криво (подделка)"
-gg.print.note,"Разъём питания и число вентиляторов определяются настоящим чипом, поэтому подделка никогда не совпадает с заявленной моделью. Серийный номер и маркировку могут сделать аккуратно, поэтому отсутствие изъянов не доказывает, что карта подлинная."
-gg.seller.h,Слова продавца
-gg.seller.body,"Дилеры подержанного оборудования бывают трёх видов:\n\n      - Честный: говорит правду.\n      - Посредник: каждый пункт называет исправным с вероятностью {UsedMiddlemanHide:%} и добавляет к цене {UsedMiddlemanMarkup:%}; {UsedFakeMiddleman:%} карт — подделки.\n      - Мошенник: всё называет исправным, около {UsedFakeScammer:%} карт — подделки, а цену назначает как за заявленную модель.\n\nДо покупки действуют слова продавца; после покупки карта показывает своё настоящее состояние."
 gg.point.h,Указание
-gg.point.body,"Карту осматривают через лупу; справа в каждой строке панели ярлыков находится «Указать». Если указать скрытую проблему, строка меняется на фактическое состояние, а цена снижается на разницу; если указать то, что правда, продавец отказывается, а репутация падает.\nЕсли указать модель, она меняется на настоящий чип, и выводится список найденных проблем.\n\nКарты клиентов гильдии оценщиков тоже сопровождаются заявлением: указание проблем меняет оценку, пока не будет названа правильная стоимость. Когда своя карта показывается покупателю, каждый скрытый пункт замечают с вероятностью {CustomerSpotChance:%}."
-gg.ex.h,Пример оценки
 gg.ex.card,"Пример: {0}, прочность {1}%"
 gg.ex.base,Базовая стоимость: +{0}
 gg.ex.fan,Скол на лопасти: -{0}
@@ -881,3 +866,29 @@ gg.ex.h3,Пример оценки: сильный износ
 gg.ex.h4,Пример оценки: лёгкий износ
 gg.ex.h5,Пример оценки: новая
 lbl.price,Цена по ярлыку: {0}
+lbl.row.count,Вентиляторы
+lbl.row.pin,Питание
+lbl.count.1,1 вентилятор
+lbl.count.2,2 вентилятора
+lbl.count.3,3 вентилятора
+lbl.pin.0,6-pin
+lbl.pin.1,8-pin
+lbl.pin.2,2×8-pin
+gg.p1.body,"Видеокарты — ключевой компонент любой майнинг-фермы и самый часто подделываемый товар на вторичном рынке.\nПодлинность карты определяют четыре признака: число вентиляторов, разъём питания, маркировка на обратной стороне и серийный номер. Подлинна только та карта, у которой все четыре признака соответствуют заявленной модели; любое одно несоответствие означает подделку.\nСтоимость карты зависит от модели настоящего чипа и от её состояния, а каждый след износа снижает цену.\n\nЭто руководство содержит все знания, необходимые для оценки видеокарты."
+gg.p2.h,Модели видеокарт
+gg.p2.body,Модель определяет число вентиляторов и разъём питания. Подделка — это чип низшей модели в корпусе высшей; её производительность и стоимость определяются настоящим чипом внутри.
+gg.tier.0,"RTX 60 / RX 70: 6-pin, 1 вент."
+gg.tier.1,"RTX 70 / RX 80: 8-pin, 2 вент."
+gg.tier.2,"RTX 80 / RX 800: 8-pin, 3 вент."
+gg.tier.3,"RTX 90 / RX 900: 2×8-pin, 3 вент."
+gg.count.h,Число вентиляторов
+gg.count.body,"Число вентиляторов определяется моделью: один вентилятор у RTX 60 и RX 70, два у RTX 70 и RX 80, три у RTX 80, RTX 90, RX 800 и RX 900.\nЧисло вентиляторов, не соответствующее заявленной модели, означает подделку."
+gg.pin.h,Разъём питания
+gg.pin.body,"Разъём питания тоже определяется моделью: 6-pin у RTX 60 и RX 70, 8-pin у RTX 70, RTX 80, RX 80 и RX 800, 2×8-pin у RTX 90 и RX 900.\nРазъём питания, не соответствующий заявленной модели, означает подделку."
+gg.serial.body,"Серийный номер наклеен на обратной стороне карты и состоит из префикса, кода модели, дефиса, двузначного кода завода, дефиса и четырёхзначного порядкового номера, например PB2-21-6251."
+gg.serial.rule,"Коды модели от 1 до 4 соответствуют RTX 60 / RX 70, RTX 70 / RX 80, RTX 80 / RX 800 и RTX 90 / RX 900.\nКод модели, не соответствующий модели (наклейка от исходного чипа), либо недопустимый код завода или длина (наклейка добавлена позже) означает подделку. Код завода служит только для проверки подлинности и на цену не влияет."
+gg.print.note,"Карта подлинна, только если число вентиляторов, разъём питания, маркировка и серийный номер соответствуют модели. У подделки не совпадает хотя бы один признак, но остальные могут быть выполнены правильно, поэтому проверять нужно каждый."
+gg.cond.h,Лопасти и контакты
+gg.point.body,"Осмотр выполняется с помощью лупы; справа в каждой строке панели меток находится «Указать». Если указать на скрытую проблему, строка меняется на реальное состояние, а цена снижается на разницу; если указать на то, что соответствует действительности, другая сторона отказывается, и репутация страдает.\nЕсли число вентиляторов, разъём питания, маркировка или серийный номер не соответствуют модели, на это следует указать: карта признаётся подделкой, модель меняется на настоящий чип, а цена пересчитывается по этому чипу.\n\nКарты, которые приносят клиенты гильдии оценщиков, обрабатываются так же: после указания проблем оценка меняется, пока не будет названа правильная стоимость."
+gg.ex.serial,Серийный номер: {0}
+gg.ex.h,"Пример оценки: скол на лопасти, потускневшие контакты, нет пломбы"
@@ -108,7 +108,7 @@ lbl.bracket.0,"完好"
 lbl.bracket.1,"有划痕"
 lbl.serial.0,"合规"
 lbl.serial.1,"工厂码或位数不合规"
-lbl.serial.2,"档次码与型号不符"
+lbl.serial.2,"型号码不符"
 lbl.seal.0,"完好"
 lbl.seal.2,"已缺失"
 lbl.tier.0,"低端"
@@ -819,17 +819,9 @@ settings.risk_scale_desc,骗局、跑路、钱包投毒、地址劫持和钓鱼
 settings.mining_scale,挖矿产出倍率
 settings.mining_scale_desc,挖矿设备拿到的区块奖励倍数。对所有存档生效。
 gg.header,空间站贸易委员会
-gg.p1.body,显卡是矿机的核心部件，也是二手市场上最常被假冒的货物。\n显卡的价值取决于真实芯片的型号和健康度，外观上的每一处磨损都会折价。\n\n本指南将提供鉴定显卡价值所需的全部知识。
 gg.p1.cap,显卡图示
 gg.p1.makers,空间站上共有两家常见的制造商：\n\n      - Probidia（“PB”）\n      - PMD（“MD”）
 gg.p1.note,无论制造商是谁，显卡的价值只取决于真实芯片的型号定价和健康度：满健康时等于型号定价，健康度为 0 时只剩 {CardValueFloor:%}。
-gg.p2.h,显卡档次
-gg.p2.body,档次决定供电口和风扇数。型号只是显示名，真实档次要看实物。\n假冒显卡是低档次的芯片套着高档次的外壳，性能和价值都按里面的真实芯片算。
-gg.tier.0,低端（6 针，单风扇）
-gg.tier.1,中端（8 针，双风扇）
-gg.tier.2,高端（8 针，三风扇）
-gg.tier.3,旗舰（双 8 针，三风扇）
-gg.p2.models,Probidia：RTX 60 / 70 / 80 / 90\nPMD：RX 70 / 80 / 800 / 900\n型号依次对应低端、中端、高端、旗舰。
 gg.fan.h,叶片
 gg.fan.0,叶片干净（价格不变）
 gg.fan.1,叶片积灰（-{CardFanDust:%}）
@@ -846,21 +838,14 @@ gg.seal.0,封条完好（价格不变）
 gg.seal.2,封条缺失（-{CardSealMissing:%}）
 gg.wear.note,叶片、金手指、挡板随每晚损耗变差，只会越来越旧；封条是固定特征。成色还会影响算力、损耗和暴毙概率。
 gg.serial.h,序列号
-gg.serial.body,序列号贴在显卡背面，格式为：前缀、档次码、连字符、两位工厂码、连字符、四位流水号，例如 PB2-21-6251。
 gg.serial.cap,背面图示（序列号贴纸）
 gg.serial.pb,Probidia（“PB”）\n      合规工厂码：11、12、21、34、47
 gg.serial.md,PMD（“MD”）\n      合规工厂码：13、22、35、41、58
-gg.serial.rule,档次码 1 至 4 依次对应低端到旗舰。\n档次码与型号不符（贴的是原芯片的序列号），或工厂码、位数不合规（后补的贴纸），均为假冒。工厂码只用来判真伪，不影响价格。
 gg.print.h,背面丝印
 gg.print.0,与型号一致
 gg.print.1,印着另一个型号（假冒）
 gg.print.2,重印过，字歪（假冒）
-gg.print.note,供电口与风扇数由真实芯片决定，假冒显卡一定对不上标称型号。序列号和丝印可能被做得规矩，所以没有破绽不等于是真货。
-gg.seller.h,卖家的说法
-gg.seller.body,二手贩子分三种：\n\n      - 老实人：如实说。\n      - 中间商：每项有 {UsedMiddlemanHide:%} 的概率说成没问题，另加价 {UsedMiddlemanMarkup:%}，{UsedFakeMiddleman:%} 的卡是假冒。\n      - 骗子：全部说成没问题，约 {UsedFakeScammer:%} 的卡是假冒，并按标称型号报价。\n\n买下之前，卖家的说法有效；买下后，卡回到真实情况。
 gg.point.h,指出
-gg.point.body,用放大镜检视，标签栏每行右边是“指出”。指出隐瞒的问题，这一行改成真实情况，价格按差额回落；指出的是真话，对方不认，信誉受损。\n指出型号，型号自动改回真实芯片，并列出查到的问题。\n\n鉴定公会的客户带来的卡同样带一份说法，指出问题后估价跟着变，最后报出正确价值。自己的卡摆给顾客时，说法里隐瞒的每一项，顾客有 {CustomerSpotChance:%} 的概率看出来。
-gg.ex.h,鉴定示例
 gg.ex.card,示例：{0}，健康度 {1}%
 gg.ex.base,基础价值：+{0}
 gg.ex.fan,叶片缺角：-{0}
@@ -880,3 +865,29 @@ gg.ex.h3,鉴定示例：成色很差的显卡
 gg.ex.h4,鉴定示例：轻微使用
 gg.ex.h5,鉴定示例：全新显卡
 lbl.price,标签价：{0}
+lbl.row.count,风扇数
+lbl.row.pin,供电口
+lbl.count.1,单风扇
+lbl.count.2,双风扇
+lbl.count.3,三风扇
+lbl.pin.0,6 针
+lbl.pin.1,8 针
+lbl.pin.2,双 8 针
+gg.p1.body,显卡是矿机的核心部件，也是二手市场上最常被假冒的货物。\n判断一张显卡是不是正品，看四项：风扇数、供电口、背面丝印、序列号。四项全部符合标称型号才是正品，任何一项对不上就是假冒。\n显卡的价值取决于真实芯片的型号和健康度，外观上的每一处磨损都会折价。\n\n本指南将提供鉴定显卡所需的全部知识。
+gg.p2.h,显卡型号
+gg.p2.body,型号决定风扇数和供电口。假冒显卡是低型号的芯片套着高型号的外壳，性能和价值都按里面的真实芯片算。
+gg.tier.0,RTX 60 / RX 70：6 针，单风扇
+gg.tier.1,RTX 70 / RX 80：8 针，双风扇
+gg.tier.2,RTX 80 / RX 800：8 针，三风扇
+gg.tier.3,RTX 90 / RX 900：双 8 针，三风扇
+gg.count.h,风扇数
+gg.count.body,风扇数由型号决定：RTX 60 和 RX 70 为单风扇，RTX 70 和 RX 80 为双风扇，RTX 80、RTX 90、RX 800 和 RX 900 为三风扇。\n实物的风扇数对不上标称型号，即为假冒。
+gg.pin.h,供电口
+gg.pin.body,供电口也由型号决定：RTX 60 和 RX 70 为 6 针，RTX 70、RTX 80、RX 80 和 RX 800 为 8 针，RTX 90 和 RX 900 为双 8 针。\n实物的供电口对不上标称型号，即为假冒。
+gg.serial.body,序列号贴在显卡背面，格式为：前缀、型号码、连字符、两位工厂码、连字符、四位流水号，例如 PB2-21-6251。
+gg.serial.rule,型号码 1 至 4 依次对应 RTX 60 / RX 70、RTX 70 / RX 80、RTX 80 / RX 800、RTX 90 / RX 900。\n型号码与型号不符（贴的是原芯片的序列号），或工厂码、位数不合规（后补的贴纸），均为假冒。工厂码只用来判真伪，不影响价格。
+gg.print.note,风扇数、供电口、丝印、序列号四项全部符合才是正品。假冒显卡至少有一项对不上，但可能其余几项都做得规矩，所以每一项都要看。
+gg.cond.h,叶片与金手指
+gg.point.body,用放大镜检视，标签栏每行右边是“指出”。指出隐瞒的问题，这一行改成真实情况，价格按差额回落；指出的是真话，对方不认，信誉受损。\n风扇数、供电口、丝印、序列号任何一项对不上，指出它，这张卡就被认定为假冒，型号改回真实芯片，价格按真实芯片重算。\n\n鉴定公会的客户带来的卡也一样：指出问题后估价跟着变，最后报出正确价值。
+gg.ex.serial,序列号：{0}
+gg.ex.h,鉴定示例：叶片缺角、金手指发暗、封条缺失
@@ -150,8 +150,6 @@ internal static class Program
                seen.Add($"{oldReal.Fan}{oldReal.Fingers}{oldReal.Bracket}{oldReal.Print}{oldReal.Sticker}");
            }
            Check(realSign == 0, "真卡从不出现破绽类取值（丝印不对、序列号不合规）");
-            Check(fakeNoSign > n * 0.1 && fakeNoSign < n * 0.3, $"假卡里一成多的骗子没动丝印和序列号（只剩供电与风扇这一处实物破绽）：{fakeNoSign / (double)n:P0}");
-            Check(Near(fakeSigns / (double)n, 0.55 * 1 + 0.65 * 1, 0.1), $"假卡平均 1.2 处额外破绽（重印丝印、补贴序列号）：{fakeSigns / (double)n:0.00}");
            Check(oldWorn > newWorn * 1.8, $"低健康度的真卡明显更旧：{oldWorn / (double)n:P0} 对 {newWorn / (double)n:P0}");
            Check(seen.Count >= 60, $"抽样见到 {seen.Count} 种不同组合（上限 243）");
            Check(Hardware.Specs["RTX60"].Price == 220 && Hardware.Specs["RTX90"].Price == 5000 && Hardware.Specs["RX900"].Price == 4000, "价格已抬高到约 1.8 倍");
@@ -409,7 +407,7 @@ internal static class Program
            int ex2 = 0;
            var honestUnit = new Unit { Model = "RTX70", Health = 60, Look = new CardLook { Fan = 1 } };
            Check(CardLabels.Point(honestUnit, CardLabels.DealerClaim(honestUnit, DealerKind.Honest, new Rng(1)), CardLabels.RowFan, ref ex2) == 0, "老实人说的是实话，指出去没用");
-            Check(CardLabels.Lies(u, claim, 0) == (CardLabels.RowSpec | CardLabels.RowFan | CardLabels.RowFingers), "骗子隐瞒了型号、叶片、金手指");
+            Check(CardLabels.Lies(u, claim, 0) == (CardLabels.RowSpec | CardLabels.RowFan | CardLabels.RowFingers | CardLabels.RowPrint), "骗子隐瞒了型号、丝印、叶片、金手指");
            Check(CardLabels.Lies(u, claim, ex) == 0, "指出之后不再算隐瞒");
            Check(Claim.Decode(claim.Encode()).Encode() == claim.Encode(), "说法能存取");
        });
@@ -435,11 +433,39 @@ internal static class Program
            var forged = new Unit { Model = "RTX90", FakeOf = "RTX60", Health = 100, Look = new CardLook { Seed = 7, Serial = 1 } };
            var f = CardLabels.SerialText(forged);
            Check(f.StartsWith("PB4-") && (!CardLabels.Factories("Probidia").Contains(int.Parse(f.Substring(4, 2))) || f.Length == 10), $"补贴的序列号：档次码对，工厂码不合法或位数不对：{f}");
-            var original = new Unit { Model = "RTX90", FakeOf = "RTX60", Health = 100, Look = new CardLook { Seed = 7, Serial = 2 } };
+            var original = new Unit { Model = "RTX90", FakeOf = "RTX60", Health = 100, Look = new CardLook { Seed = 7, Serial = 2, CountBad = 1, PinBad = 1 } };
            Check(CardLabels.SerialText(original).StartsWith("PB1-"), "贴的是原芯片的序列号：档次码是真实芯片的档次");
            var claim = CardLabels.DealerClaim(original, DealerKind.Scammer, new Rng(1));
            int ex = 0;
-            Check(CardLabels.Point(original, claim, CardLabels.RowBuild, ref ex) == 2 && (ex & CardLabels.RowSpec) != 0 && CardLabels.Value(original, claim, ex) == CardValue.True(original), "指出供电与风扇：型号自动改回真实型号，价格回到真实价值");
+            Check(CardLabels.Point(original, claim, CardLabels.RowCount, ref ex) == 2 && (ex & CardLabels.RowSpec) != 0 && CardLabels.Value(original, claim, ex) == CardValue.True(original), "指出供电与风扇：型号自动改回真实型号，价格回到真实价值");
+        });
+
+        Test("假卡的四项真伪依据（风扇数、供电口、丝印、序列号）：各自独立露出，至少一项，平均约 1.5 项；真卡全部符合", () =>
+        {
+            var rng = new Rng(2024);
+            int n = 20000; double sum = 0; int[] per = new int[4]; int none = 0;
+            for (int i = 0; i < n; i++)
+            {
+                var label = new[] { "RTX70", "RTX80", "RTX90", "RX80", "RX800", "RX900" }[rng.Range(0, 5)];
+                var cheaper = Hardware.Specs.Values.Where(x => !x.Asic && !x.Scrap && x.Brand == Hardware.Specs[label].Brand && x.Tier < Hardware.Specs[label].Tier).ToArray();
+                var chip = cheaper[rng.Range(0, cheaper.Length - 1)];
+                var look = CardLook.Generate(rng, 70, true, Hardware.Specs[label].Tier, chip.Tier);
+                var u = new Unit { Model = label, FakeOf = chip.Model, Health = 70, Look = look };
+                var real = Claim.Truth(u); var said = new Claim { Model = label };
+                int c = 0;
+                int k = 0;
+                foreach (int r in new[] { CardLabels.RowCount, CardLabels.RowPin, CardLabels.RowPrint, CardLabels.RowSerial })
+                { if (said.Get(r) != real.Get(r)) { c++; per[k]++; } k++; }
+                if (c == 0) none++;
+                sum += c;
+            }
+            double mean = sum / n;
+            Check(none == 0, "假卡至少有一项依据不符");
+            Check(mean > 1.4 && mean < 1.6, $"假卡平均露出 {mean:0.00} 项依据（目标约 1.5）");
+            Check(per.All(x => x > n * 0.1), "四项都会单独露出：" + string.Join(" ", per));
+            var genuine = new Unit { Model = "RTX80", Health = 70, Look = CardLook.Generate(rng, 70, false) };
+            var gt = Claim.Truth(genuine); var gs = new Claim { Model = "RTX80" };
+            Check(new[] { CardLabels.RowCount, CardLabels.RowPin, CardLabels.RowPrint, CardLabels.RowSerial }.All(r => gs.Get(r) == gt.Get(r)), "真卡四项依据全部符合");
        });

        Test("外观随损耗重算：越旧外观越差；种子固定；算力受风扇与金手指影响", () =>