diff --git a/internal/number/decimal.go b/internal/number/decimal.go
index a323ae7..eedc76f 100644
--- a/internal/number/decimal.go
+++ b/internal/number/decimal.go
@@ -275,29 +275,29 @@
 		d.clear()
 		f.Convert(d, r)
 	case float32:
-		d.convertFloat64(r, float64(f), 32)
+		d.ConvertFloat(r, float64(f), 32)
 	case float64:
-		d.convertFloat64(r, f, 64)
+		d.ConvertFloat(r, f, 64)
 	case int:
-		d.convertInt(r, signed, uint64(f))
+		d.ConvertInt(r, signed, uint64(f))
 	case int8:
-		d.convertInt(r, signed, uint64(f))
+		d.ConvertInt(r, signed, uint64(f))
 	case int16:
-		d.convertInt(r, signed, uint64(f))
+		d.ConvertInt(r, signed, uint64(f))
 	case int32:
-		d.convertInt(r, signed, uint64(f))
+		d.ConvertInt(r, signed, uint64(f))
 	case int64:
-		d.convertInt(r, signed, uint64(f))
+		d.ConvertInt(r, signed, uint64(f))
 	case uint:
-		d.convertInt(r, unsigned, uint64(f))
+		d.ConvertInt(r, unsigned, uint64(f))
 	case uint8:
-		d.convertInt(r, unsigned, uint64(f))
+		d.ConvertInt(r, unsigned, uint64(f))
 	case uint16:
-		d.convertInt(r, unsigned, uint64(f))
+		d.ConvertInt(r, unsigned, uint64(f))
 	case uint32:
-		d.convertInt(r, unsigned, uint64(f))
+		d.ConvertInt(r, unsigned, uint64(f))
 	case uint64:
-		d.convertInt(r, unsigned, f)
+		d.ConvertInt(r, unsigned, f)
 
 		// TODO:
 		// case string: if produced by strconv, allows for easy arbitrary pos.
@@ -310,13 +310,14 @@
 	}
 }
 
-func (d *Decimal) convertInt(r *RoundingContext, signed bool, x uint64) {
+// ConvertInt converts an integer to decimals.
+func (d *Decimal) ConvertInt(r *RoundingContext, signed bool, x uint64) {
 	if r.Increment > 0 {
 		// TODO: if uint64 is too large, fall back to float64
 		if signed {
-			d.convertFloat64(r, float64(int64(x)), 64)
+			d.ConvertFloat(r, float64(int64(x)), 64)
 		} else {
-			d.convertFloat64(r, float64(x), 64)
+			d.ConvertFloat(r, float64(x), 64)
 		}
 		return
 	}
@@ -329,7 +330,8 @@
 	d.Exp = int32(len(d.Digits))
 }
 
-func (d *Decimal) convertFloat64(r *RoundingContext, x float64, size int) {
+// ConvertFloat converts a floating point number to decimals.
+func (d *Decimal) ConvertFloat(r *RoundingContext, x float64, size int) {
 	d.clear()
 	if math.IsNaN(x) {
 		d.NaN = true
diff --git a/internal/number/format.go b/internal/number/format.go
index 84903fa..9ceaf04 100755
--- a/internal/number/format.go
+++ b/internal/number/format.go
@@ -6,41 +6,128 @@
 
 import (
 	"strconv"
+	"unicode/utf8"
 
 	"golang.org/x/text/language"
 )
 
 // TODO:
-// - public (but internal) API for creating formatters
 // - split out the logic that computes the visible digits from the rest of the
 //   formatting code (needed for plural).
 // - grouping of fractions
-// - reuse percent pattern for permille
-// - padding
 
 // Formatter contains all the information needed to render a number.
 type Formatter struct {
-	*Pattern
+	Pattern
 	Info
 	RoundingContext
-	f func(dst []byte, f *Formatter, d *Decimal) []byte
 }
 
-func lookupFormat(t language.Tag, tagToIndex []uint8) *Pattern {
+func (f *Formatter) init(t language.Tag, index []uint8) {
+	f.Info = InfoFromTag(t)
 	for ; ; t = t.Parent() {
 		if ci, ok := language.CompactIndex(t); ok {
-			return &formats[tagToIndex[ci]]
+			f.Pattern = formats[index[ci]]
+			break
 		}
 	}
 }
 
-func (f *Formatter) Format(dst []byte, d *Decimal) []byte {
-	return f.f(dst, f, d)
+// InitPattern initializes a Formatter for the given Pattern.
+func (f *Formatter) InitPattern(t language.Tag, pat *Pattern) {
+	f.Info = InfoFromTag(t)
+	f.Pattern = *pat
 }
 
-func appendDecimal(dst []byte, f *Formatter, d *Decimal) []byte {
+// InitDecimal initializes a Formatter using the default Pattern for the given
+// language.
+func (f *Formatter) InitDecimal(t language.Tag) {
+	f.init(t, tagToDecimal)
+}
+
+// InitScientific initializes a Formatter using the default Pattern for the
+// given language.
+func (f *Formatter) InitScientific(t language.Tag) {
+	f.init(t, tagToScientific)
+}
+
+// InitEngineering initializes a Formatter using the default Pattern for the
+// given language.
+func (f *Formatter) InitEngineering(t language.Tag) {
+	f.init(t, tagToScientific)
+	f.Pattern.MaxIntegerDigits = 3
+	f.Pattern.MinIntegerDigits = 1
+}
+
+// InitPercent initializes a Formatter using the default Pattern for the given
+// language.
+func (f *Formatter) InitPercent(t language.Tag) {
+	f.init(t, tagToPercent)
+}
+
+// InitPerMille initializes a Formatter using the default Pattern for the given
+// language.
+func (f *Formatter) InitPerMille(t language.Tag) {
+	f.init(t, tagToPercent)
+	f.Pattern.DigitShift = 3
+}
+
+func (f *Formatter) Append(dst []byte, x interface{}) []byte {
+	var d Decimal
+	d.Convert(&f.RoundingContext, x)
+	return f.Format(dst, &d)
+}
+
+func (f *Formatter) Format(dst []byte, d *Decimal) []byte {
+	var result []byte
+	var postPrefix, preSuffix int
+	if f.MinExponentDigits > 0 {
+		result, postPrefix, preSuffix = appendScientific(dst, f, d)
+	} else {
+		result, postPrefix, preSuffix = appendDecimal(dst, f, d)
+	}
+	if f.PadRune == 0 {
+		return result
+	}
+	width := int(f.FormatWidth)
+	if count := utf8.RuneCount(result); count < width {
+		insertPos := 0
+		switch f.Flags & PadMask {
+		case PadAfterPrefix:
+			insertPos = postPrefix
+		case PadBeforeSuffix:
+			insertPos = preSuffix
+		case PadAfterSuffix:
+			insertPos = len(result)
+		}
+		num := width - count
+		pad := [utf8.UTFMax]byte{' '}
+		sz := 1
+		if r := f.PadRune; r != 0 {
+			sz = utf8.EncodeRune(pad[:], r)
+		}
+		extra := sz * num
+		if n := len(result) + extra; n < cap(result) {
+			result = result[:n]
+			copy(result[insertPos+extra:], result[insertPos:])
+		} else {
+			buf := make([]byte, n)
+			copy(buf, result[:insertPos])
+			copy(buf[insertPos+extra:], result[insertPos:])
+			result = buf
+		}
+		for ; num > 0; num-- {
+			insertPos += copy(result[insertPos:], pad[:sz])
+		}
+	}
+	return result
+}
+
+// appendDecimal appends a formatted number to dst. It returns two possible
+// insertion points for padding.
+func appendDecimal(dst []byte, f *Formatter, d *Decimal) (b []byte, postPre, preSuf int) {
 	if dst, ok := f.renderSpecial(dst, d); ok {
-		return dst
+		return dst, 0, len(dst)
 	}
 	n := d.normalize()
 	if maxSig := int(f.MaxSignificantDigits); maxSig > 0 {
@@ -48,6 +135,7 @@
 	}
 	digits := n.Digits
 	exp := n.Exp
+	exp += int32(f.Pattern.DigitShift)
 
 	// Split in integer and fraction part.
 	var intDigits, fracDigits []byte
@@ -148,12 +236,14 @@
 	if len(dst) == savedLen {
 		dst = f.AppendDigit(dst, 0)
 	}
-	return appendAffix(dst, f, suffix, neg)
+	return appendAffix(dst, f, suffix, neg), savedLen, len(dst)
 }
 
-func appendScientific(dst []byte, f *Formatter, d *Decimal) []byte {
+// appendScientific appends a formatted number to dst. It returns two possible
+// insertion points for padding.
+func appendScientific(dst []byte, f *Formatter, d *Decimal) (b []byte, postPre, preSuf int) {
 	if dst, ok := f.renderSpecial(dst, d); ok {
-		return dst
+		return dst, 0, 0
 	}
 	// Significant digits are transformed by parser for scientific notation and
 	// do not need to be handled here.
@@ -244,14 +334,14 @@
 		dst = append(dst, f.Symbol(SymPlusSign)...)
 	}
 	buf := [12]byte{}
-	b := strconv.AppendUint(buf[:0], uint64(exp), 10)
+	b = strconv.AppendUint(buf[:0], uint64(exp), 10)
 	for i := len(b); i < int(f.MinExponentDigits); i++ {
 		dst = f.AppendDigit(dst, 0)
 	}
 	for _, c := range b {
 		dst = f.AppendDigit(dst, c-'0')
 	}
-	return appendAffix(dst, f, suffix, neg)
+	return appendAffix(dst, f, suffix, neg), savedLen, len(dst)
 }
 
 func (f *Formatter) getAffixes(neg bool) (affix, suffix string) {
@@ -307,7 +397,15 @@
 			escaping = true
 		case r == '\'':
 			quoting = !quoting
-		case !quoting && (r == '-' || r == '+'):
+		case quoting:
+			dst = append(dst, string(r)...)
+		case r == '%':
+			if f.DigitShift == 3 {
+				dst = append(dst, f.Symbol(SymPerMille)...)
+			} else {
+				dst = append(dst, f.Symbol(SymPercentSign)...)
+			}
+		case r == '-' || r == '+':
 			if neg {
 				dst = append(dst, f.Symbol(SymMinusSign)...)
 			} else {
diff --git a/internal/number/format_test.go b/internal/number/format_test.go
index 355a33a..850ad82 100755
--- a/internal/number/format_test.go
+++ b/internal/number/format_test.go
@@ -7,7 +7,6 @@
 import (
 	"fmt"
 	"log"
-	"strings"
 	"testing"
 
 	"golang.org/x/text/language"
@@ -287,22 +286,139 @@
 			"12345":   "12.34E03",
 			"123.456": "123.4E00",
 		},
+	}, {
+		pattern: "@@E0",
+		test: pairs{
+			"0":    "0.0E0",
+			"99":   "9.9E1",
+			"0.99": "9.9E-1",
+		},
+	}, {
+		pattern: "@###E00",
+		test: pairs{
+			"0":     "0E00",
+			"1":     "1E00",
+			"11":    "1.1E01",
+			"111":   "1.11E02",
+			"1111":  "1.111E03",
+			"11111": "1.111E04",
+			"0.1":   "1E-01",
+			"0.11":  "1.1E-01",
+			"0.001": "1E-03",
+		},
+	}, {
+		pattern: "*x###",
+		test: pairs{
+			"0":    "xx0",
+			"10":   "x10",
+			"100":  "100",
+			"1000": "1000",
+		},
+	}, {
+		pattern: "###*x",
+		test: pairs{
+			"0":    "0xx",
+			"10":   "10x",
+			"100":  "100",
+			"1000": "1000",
+		},
+	}, {
+		pattern: "* ###0.000",
+		test: pairs{
+			"0":        "   0.000",
+			"123":      " 123.000",
+			"123.456":  " 123.456",
+			"1234.567": "1234.567",
+		},
+	}, {
+		pattern: "**0.0##E00",
+		test: pairs{
+			"0":     "**0.0E00",
+			"10":    "**1.0E01",
+			"11":    "**1.1E01",
+			"111":   "*1.11E02",
+			"1111":  "1.111E03",
+			"11111": "1.111E04",
+			"11110": "1.111E04",
+			"11100": "*1.11E04",
+			"11000": "**1.1E04",
+			"10000": "**1.0E04",
+		},
+	}, {
+		pattern: "*xpre#suf",
+		test: pairs{
+			"0":  "pre0suf",
+			"10": "pre10suf",
+		},
+	}, {
+		pattern: "*∞ pre #### suf",
+		test: pairs{
+			"0":    "∞∞∞ pre 0 suf",
+			"10":   "∞∞ pre 10 suf",
+			"100":  "∞ pre 100 suf",
+			"1000": " pre 1000 suf",
+		},
+	}, {
+		pattern: "pre *∞#### suf",
+		test: pairs{
+			"0":    "pre ∞∞∞0 suf",
+			"10":   "pre ∞∞10 suf",
+			"100":  "pre ∞100 suf",
+			"1000": "pre 1000 suf",
+		},
+	}, {
+		pattern: "pre ####*∞ suf",
+		test: pairs{
+			"0":    "pre 0∞∞∞ suf",
+			"10":   "pre 10∞∞ suf",
+			"100":  "pre 100∞ suf",
+			"1000": "pre 1000 suf",
+		},
+	}, {
+		pattern: "pre #### suf *∞",
+		test: pairs{
+			"0":    "pre 0 suf ∞∞∞",
+			"10":   "pre 10 suf ∞∞",
+			"100":  "pre 100 suf ∞",
+			"1000": "pre 1000 suf ",
+		},
+	}, {
+		// Take width of positive pattern.
+		pattern: "**####;**-######x",
+		test: pairs{
+			"0":  "***0",
+			"-1": "*-1x",
+		},
+	}, {
+		pattern: "0.00%",
+		test: pairs{
+			"0.1": "10.00%",
+		},
+	}, {
+		pattern: "0.##%",
+		test: pairs{
+			"0.1":     "10%",
+			"0.11":    "11%",
+			"0.111":   "11.1%",
+			"0.1111":  "11.11%",
+			"0.11111": "11.11%",
+		},
+	}, {
+		pattern: "‰ 0.0#",
+		test: pairs{
+			"0.1":      "‰ 100.0",
+			"0.11":     "‰ 110.0",
+			"0.111":    "‰ 111.0",
+			"0.1111":   "‰ 111.1",
+			"0.11111":  "‰ 111.11",
+			"0.111111": "‰ 111.11",
+		},
 	}}
 
 	// TODO:
-	// 	"@@E0",
-	// 	"@###E00",
-	// 	"0.0%",
-	// 	"0.0‰",
 	// 	"#,##0.00¤",
 	// 	"#,##0.00 ¤;(#,##0.00 ¤)",
-	// 	// padding
-	// 	"*x#",
-	// 	"#*x",
-	// 	"*xpre#suf",
-	// 	"pre*x#suf",
-	// 	"pre#*xsuf",
-	// 	"pre#suf*x",
+
 	for _, tc := range testCases {
 		pat := tc.pat
 		if pat == nil {
@@ -311,15 +427,8 @@
 				log.Fatal(err)
 			}
 		}
-		f := &Formatter{
-			pat,
-			InfoFromTag(language.English),
-			RoundingContext{},
-			appendDecimal,
-		}
-		if strings.IndexByte(tc.pattern, 'E') != -1 {
-			f.f = appendScientific
-		}
+		var f Formatter
+		f.InitPattern(language.English, pat)
 		for dec, want := range tc.test {
 			buf := make([]byte, 100)
 			t.Run(tc.pattern+"/"+dec, func(t *testing.T) {
@@ -347,12 +456,36 @@
 	}
 	for _, tc := range testCases {
 		t.Run(fmt.Sprint(tc.tag, "/", tc.num), func(t *testing.T) {
-			f := &Formatter{
-				lookupFormat(tc.tag, tagToDecimal),
-				InfoFromTag(tc.tag),
-				RoundingContext{},
-				appendDecimal,
+			var f Formatter
+			f.InitDecimal(tc.tag)
+			d := mkdec(tc.num)
+			b := f.Format(nil, &d)
+			if got := string(b); got != tc.want {
+				t.Errorf("got %q; want %q", got, tc.want)
 			}
+		})
+	}
+}
+
+func TestFormatters(t *testing.T) {
+	var f Formatter
+	testCases := []struct {
+		init func(t language.Tag)
+		num  string
+		want string
+	}{
+		{f.InitDecimal, "123456.78", "123,456.78"},
+		{f.InitScientific, "123456.78", "1.23E5"},
+		{f.InitEngineering, "123456.78", "123E3"},
+
+		{f.InitPercent, "0.1234", "12.34%"},
+		{f.InitPerMille, "0.1234", "123.40‰"},
+	}
+	for i, tc := range testCases {
+		t.Run(fmt.Sprint(i, "/", tc.num), func(t *testing.T) {
+			tc.init(language.English)
+			f.Pattern.MinFractionDigits = 2
+			f.Pattern.MaxFractionDigits = 2
 			d := mkdec(tc.num)
 			b := f.Format(nil, &d)
 			if got := string(b); got != tc.want {
diff --git a/internal/number/pattern.go b/internal/number/pattern.go
index 5610c60..8d7f9a6 100644
--- a/internal/number/pattern.go
+++ b/internal/number/pattern.go
@@ -46,11 +46,11 @@
 	Offset    uint16 // Offset into Affix for prefix and suffix
 	NegOffset uint16 // Offset into Affix for negative prefix and suffix or 0.
 
-	Multiplier     uint32
+	FormatWidth uint16
+
 	RoundIncrement uint32 // Use Min*Digits to determine scale
 	PadRune        rune
-
-	FormatWidth uint16
+	DigitShift     uint8 // Number of decimals to shift. Used for % and ‰.
 
 	GroupingSize [2]uint8
 	Flags        PatternFlag
@@ -247,26 +247,41 @@
 		'#', '@', '.', '*', ',', ';':
 		return nil
 	case '\'':
-		return p.escape
+		p.FormatWidth--
+		return p.escapeFirst
 	case '%':
-		if p.Multiplier != 0 {
+		if p.DigitShift != 0 {
 			p.setError(errDuplicatePercentSign)
 		}
-		p.Multiplier = 100
+		p.DigitShift = 2
 	case '\u2030': // ‰ Per mille
-		if p.Multiplier != 0 {
+		if p.DigitShift != 0 {
 			p.setError(errDuplicatePermilleSign)
 		}
-		p.Multiplier = 1000
+		p.DigitShift = 3
 		// TODO: handle currency somehow: ¤, ¤¤, ¤¤¤, ¤¤¤¤
 	}
 	p.buf = append(p.buf, string(r)...)
 	return p.affix
 }
 
+func (p *parser) escapeFirst(r rune) state {
+	switch r {
+	case '\'':
+		p.buf = append(p.buf, "\\'"...)
+		return p.affix
+	default:
+		p.buf = append(p.buf, '\'')
+		p.buf = append(p.buf, string(r)...)
+	}
+	return p.escape
+}
+
 func (p *parser) escape(r rune) state {
 	switch r {
 	case '\'':
+		p.FormatWidth--
+		p.buf = append(p.buf, '\'')
 		return p.affix
 	default:
 		p.buf = append(p.buf, string(r)...)
diff --git a/internal/number/pattern_test.go b/internal/number/pattern_test.go
index 6adeaf7..97ff64d 100644
--- a/internal/number/pattern_test.go
+++ b/internal/number/pattern_test.go
@@ -114,6 +114,11 @@
 		MinExponentDigits: 1,
 	},
 }, {
+	// At least one exponent digit is required. As long as this is true, one can
+	// determine that scientific rendering is needed if MinExponentDigits > 0.
+	"#E#",
+	nil,
+}, {
 	"0E0",
 	&Pattern{
 		FormatWidth:       3,
@@ -230,7 +235,7 @@
 	"0.0%",
 	&Pattern{
 		Affix:             "\x00\x01%",
-		Multiplier:        100,
+		DigitShift:        2,
 		FormatWidth:       4,
 		MinIntegerDigits:  1,
 		MinFractionDigits: 1,
@@ -240,7 +245,7 @@
 	"0.0‰",
 	&Pattern{
 		Affix:             "\x00\x03‰",
-		Multiplier:        1000,
+		DigitShift:        3,
 		FormatWidth:       4,
 		MinIntegerDigits:  1,
 		MinFractionDigits: 1,
@@ -260,7 +265,7 @@
 	"#,##0.00 ¤;(#,##0.00 ¤)",
 	&Pattern{Affix: "\x00\x04\u00a0¤\x01(\x05\u00a0¤)",
 		NegOffset:         6,
-		Multiplier:        0,
+		DigitShift:        0,
 		FormatWidth:       10,
 		GroupingSize:      [2]uint8{3, 0},
 		MinIntegerDigits:  1,
@@ -314,6 +319,19 @@
 		Flags:       PadAfterSuffix,
 	},
 }, {
+	`* #0 o''clock`,
+	&Pattern{Affix: "\x00\x09 o\\'clock",
+		FormatWidth:      10,
+		PadRune:          32,
+		MinIntegerDigits: 0x1},
+}, {
+	`'123'* #0'456'`,
+	&Pattern{Affix: "\x05'123'\x05'456'",
+		FormatWidth:      8,
+		PadRune:          32,
+		MinIntegerDigits: 0x1,
+		Flags:            PadAfterPrefix},
+}, {
 	// no duplicate padding
 	"*xpre#suf*x", nil,
 }, {
diff --git a/internal/number/tables.go b/internal/number/tables.go
index 10baa0a..defe95d 100644
--- a/internal/number/tables.go
+++ b/internal/number/tables.go
@@ -846,10 +846,10 @@
 var formats = []Pattern{Pattern{Affix: "",
 	Offset:         0x0,
 	NegOffset:      0x0,
-	Multiplier:     0x0,
+	FormatWidth:    0x0,
 	RoundIncrement: 0x0,
 	PadRune:        0,
-	FormatWidth:    0x0,
+	DigitShift:     0x0,
 	GroupingSize: [2]uint8{0x0,
 		0x0},
 	Flags:                0x0,
@@ -863,10 +863,10 @@
 	Pattern{Affix: "",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x0,
+		FormatWidth:    0x9,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x9,
+		DigitShift:     0x0,
 		GroupingSize: [2]uint8{0x3,
 			0x0},
 		Flags:                0x0,
@@ -880,10 +880,10 @@
 	Pattern{Affix: "",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x0,
+		FormatWidth:    0x3,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x3,
+		DigitShift:     0x0,
 		GroupingSize: [2]uint8{0x0,
 			0x0},
 		Flags:                0x0,
@@ -897,10 +897,10 @@
 	Pattern{Affix: "\x00\x03\u00a0%",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x64,
+		FormatWidth:    0x7,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x7,
+		DigitShift:     0x2,
 		GroupingSize: [2]uint8{0x3,
 			0x0},
 		Flags:                0x0,
@@ -914,10 +914,10 @@
 	Pattern{Affix: "\x00\x01%",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x64,
+		FormatWidth:    0x6,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x6,
+		DigitShift:     0x2,
 		GroupingSize: [2]uint8{0x3,
 			0x0},
 		Flags:                0x0,
@@ -931,10 +931,10 @@
 	Pattern{Affix: "",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x0,
+		FormatWidth:    0xc,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0xc,
+		DigitShift:     0x0,
 		GroupingSize: [2]uint8{0x3,
 			0x2},
 		Flags:                0x0,
@@ -948,10 +948,10 @@
 	Pattern{Affix: "\x00\x01%",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x64,
+		FormatWidth:    0x9,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x9,
+		DigitShift:     0x2,
 		GroupingSize: [2]uint8{0x3,
 			0x2},
 		Flags:                0x0,
@@ -965,10 +965,10 @@
 	Pattern{Affix: "\x00\x03\u00a0%",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x64,
+		FormatWidth:    0xa,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0xa,
+		DigitShift:     0x2,
 		GroupingSize: [2]uint8{0x3,
 			0x2},
 		Flags:                0x0,
@@ -982,10 +982,10 @@
 	Pattern{Affix: "",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x0,
+		FormatWidth:    0x9,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x9,
+		DigitShift:     0x0,
 		GroupingSize: [2]uint8{0x0,
 			0x0},
 		Flags:                0x0,
@@ -999,10 +999,10 @@
 	Pattern{Affix: "",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x0,
+		FormatWidth:    0xd,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0xd,
+		DigitShift:     0x0,
 		GroupingSize: [2]uint8{0x0,
 			0x0},
 		Flags:                0x2,
@@ -1016,10 +1016,10 @@
 	Pattern{Affix: "\x00\x01%",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x64,
+		FormatWidth:    0x3,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x3,
+		DigitShift:     0x2,
 		GroupingSize: [2]uint8{0x0,
 			0x0},
 		Flags:                0x0,
@@ -1033,10 +1033,10 @@
 	Pattern{Affix: "\x03%\u00a0\x00",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x64,
+		FormatWidth:    0x7,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x7,
+		DigitShift:     0x2,
 		GroupingSize: [2]uint8{0x3,
 			0x0},
 		Flags:                0x0,
@@ -1050,10 +1050,10 @@
 	Pattern{Affix: "\x03%\u00a0\x00\x04%\u00a0-\x00",
 		Offset:         0x0,
 		NegOffset:      0x5,
-		Multiplier:     0x64,
+		FormatWidth:    0x7,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x7,
+		DigitShift:     0x2,
 		GroupingSize: [2]uint8{0x3,
 			0x0},
 		Flags:                0x0,
@@ -1067,10 +1067,10 @@
 	Pattern{Affix: "\x01[\x01]",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x0,
+		FormatWidth:    0x5,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x5,
+		DigitShift:     0x0,
 		GroupingSize: [2]uint8{0x0,
 			0x0},
 		Flags:                0x0,
@@ -1084,10 +1084,10 @@
 	Pattern{Affix: "",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x0,
+		FormatWidth:    0x1,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x1,
+		DigitShift:     0x0,
 		GroupingSize: [2]uint8{0x0,
 			0x0},
 		Flags:                0x0,
@@ -1101,10 +1101,10 @@
 	Pattern{Affix: "\x01%\x00",
 		Offset:         0x0,
 		NegOffset:      0x0,
-		Multiplier:     0x64,
+		FormatWidth:    0x6,
 		RoundIncrement: 0x0,
 		PadRune:        0,
-		FormatWidth:    0x6,
+		DigitShift:     0x2,
 		GroupingSize: [2]uint8{0x3,
 			0x0},
 		Flags:                0x0,