add check for multibyte chars after switching from []byte to string

agq/agq.go

@@ -61,7 +61,7 @@ func New() locales.Translator {
 		erasAbbreviated:    []string{"SK", "BK"},
 		erasNarrow:         []string{"", ""},
 		erasWide:           []string{"Sěe Kɨ̀lesto", "Bǎa Kɨ̀lesto"},
-		timezones:          map[string]string{"JST": "JST", "∅∅∅": "∅∅∅", "AWST": "AWST", "CHADT": "CHADT", "SAST": "SAST", "SRT": "SRT", "TMST": "TMST", "COST": "COST", "CHAST": "CHAST", "WAST": "WAST", "AST": "AST", "MST": "MST", "WIT": "WIT", "IST": "IST", "CLT": "CLT", "BT": "BT", "ACST": "ACST", "AWDT": "AWDT", "MDT": "MDT", "SGT": "SGT", "ChST": "ChST", "CST": "CST", "WARST": "WARST", "HAST": "HAST", "BOT": "BOT", "WART": "WART", "ADT": "ADT", "WITA": "WITA", "ECT": "ECT", "WEZ": "WEZ", "PST": "PST", "ACDT": "ACDT", "MEZ": "MEZ", "ARST": "ARST", "JDT": "JDT", "HADT": "HADT", "CDT": "CDT", "UYT": "UYT", "PDT": "PDT", "COT": "COT", "CAT": "CAT", "OESZ": "OESZ", "MESZ": "MESZ", "HAT": "HAT", "UYST": "UYST", "AEST": "AEST", "NZDT": "NZDT", "GFT": "GFT", "ACWST": "ACWST", "ACWDT": "ACWDT", "MYT": "MYT", "LHDT": "LHDT", "HKT": "HKT", "WIB": "WIB", "VET": "VET", "HKST": "HKST", "WAT": "WAT", "AKST": "AKST", "NZST": "NZST", "GYT": "GYT", "TMT": "TMT", "WESZ": "WESZ", "GMT": "GMT", "OEZ": "OEZ", "AEDT": "AEDT", "EDT": "EDT", "CLST": "CLST", "EST": "EST", "ART": "ART", "HNT": "HNT", "EAT": "EAT", "LHST": "LHST", "AKDT": "AKDT"},
+		timezones:          map[string]string{"GMT": "GMT", "LHDT": "LHDT", "ACWDT": "ACWDT", "AST": "AST", "WARST": "WARST", "HKT": "HKT", "SAST": "SAST", "WESZ": "WESZ", "HNT": "HNT", "HAT": "HAT", "UYT": "UYT", "HADT": "HADT", "ACWST": "ACWST", "PST": "PST", "TMT": "TMT", "COT": "COT", "EAT": "EAT", "MDT": "MDT", "JST": "JST", "AEDT": "AEDT", "PDT": "PDT", "AWST": "AWST", "TMST": "TMST", "MEZ": "MEZ", "LHST": "LHST", "MESZ": "MESZ", "OESZ": "OESZ", "MYT": "MYT", "HKST": "HKST", "BT": "BT", "ARST": "ARST", "EDT": "EDT", "NZDT": "NZDT", "MST": "MST", "ADT": "ADT", "AEST": "AEST", "IST": "IST", "CAT": "CAT", "UYST": "UYST", "ECT": "ECT", "CLT": "CLT", "CLST": "CLST", "WIT": "WIT", "GFT": "GFT", "WAT": "WAT", "WIB": "WIB", "VET": "VET", "SRT": "SRT", "WITA": "WITA", "EST": "EST", "AKST": "AKST", "∅∅∅": "∅∅∅", "CHADT": "CHADT", "ACST": "ACST", "WAST": "WAST", "HAST": "HAST", "AKDT": "AKDT", "CHAST": "CHAST", "ACDT": "ACDT", "SGT": "SGT", "GYT": "GYT", "BOT": "BOT", "ChST": "ChST", "WEZ": "WEZ", "OEZ": "OEZ", "WART": "WART", "ART": "ART", "CST": "CST", "COST": "COST", "NZST": "NZST", "AWDT": "AWDT", "CDT": "CDT", "JDT": "JDT"},
 	}
 }
 
@@ -171,7 +171,8 @@ func (agq *agq) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'agq' and handles both Whole and Real numbers based on 'v'
-func (agq *agq) FmtNumber(num float64, v uint64) (results string) {
+func (agq *agq) FmtNumber(num float64, v uint64) string {
+
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(agq.decimal) + len(agq.group)*len(s[:len(s)-int(v)-1])/3
 	count := 0
@@ -191,7 +192,6 @@ func (agq *agq) FmtNumber(num float64, v uint64) (results string) {
 				for j := len(agq.group) - 1; j >= 0; j-- {
 					b = append(b, agq.group[j])
 				}
-
 				count = 1
 			} else {
 				count++
@@ -202,9 +202,7 @@ func (agq *agq) FmtNumber(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(agq.minus) - 1; j >= 0; j-- {
-			b = append(b, agq.minus[j])
-		}
+		b = append(b, agq.minus[0])
 	}
 
 	// reverse
@@ -212,13 +210,12 @@ func (agq *agq) FmtNumber(num float64, v uint64) (results string) {
 		b[i], b[j] = b[j], b[i]
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'agq' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (agq *agq) FmtPercent(num float64, v uint64) (results string) {
+func (agq *agq) FmtPercent(num float64, v uint64) string {
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(agq.decimal)
 	b := make([]byte, 0, l)
@@ -234,9 +231,7 @@ func (agq *agq) FmtPercent(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(agq.minus) - 1; j >= 0; j-- {
-			b = append(b, agq.minus[j])
-		}
+		b = append(b, agq.minus[0])
 	}
 
 	// reverse
@@ -246,12 +241,11 @@ func (agq *agq) FmtPercent(num float64, v uint64) (results string) {
 
 	b = append(b, agq.percent...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'agq'
-func (agq *agq) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (agq *agq) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := agq.currencies[currency]
@@ -273,7 +267,6 @@ func (agq *agq) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 				for j := len(agq.group) - 1; j >= 0; j-- {
 					b = append(b, agq.group[j])
 				}
-
 				count = 1
 			} else {
 				count++
@@ -284,9 +277,7 @@ func (agq *agq) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 	}
 
 	if num < 0 {
-		for j := len(agq.minus) - 1; j >= 0; j-- {
-			b = append(b, agq.minus[j])
-		}
+		b = append(b, agq.minus[0])
 	}
 
 	// reverse
@@ -307,13 +298,12 @@ func (agq *agq) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 
 	b = append(b, symbol...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'agq'
 // in accounting notation.
-func (agq *agq) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (agq *agq) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := agq.currencies[currency]
@@ -335,7 +325,6 @@ func (agq *agq) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 				for j := len(agq.group) - 1; j >= 0; j-- {
 					b = append(b, agq.group[j])
 				}
-
 				count = 1
 			} else {
 				count++
@@ -347,9 +336,7 @@ func (agq *agq) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 
 	if num < 0 {
 
-		for j := len(agq.minus) - 1; j >= 0; j-- {
-			b = append(b, agq.minus[j])
-		}
+		b = append(b, agq.minus[0])
 
 	}
 
@@ -376,8 +363,7 @@ func (agq *agq) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 		b = append(b, symbol...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'agq'

agq_CM/agq_CM.go

@@ -61,7 +61,7 @@ func New() locales.Translator {
 		erasAbbreviated:    []string{"SK", "BK"},
 		erasNarrow:         []string{"", ""},
 		erasWide:           []string{"Sěe Kɨ̀lesto", "Bǎa Kɨ̀lesto"},
-		timezones:          map[string]string{"ACST": "ACST", "AKST": "AKST", "CLST": "CLST", "GMT": "GMT", "MESZ": "MESZ", "ACWDT": "ACWDT", "MDT": "MDT", "IST": "IST", "EAT": "EAT", "COT": "COT", "AST": "AST", "ADT": "ADT", "GFT": "GFT", "TMT": "TMT", "ECT": "ECT", "OESZ": "OESZ", "PDT": "PDT", "MYT": "MYT", "BOT": "BOT", "BT": "BT", "WITA": "WITA", "HAST": "HAST", "SGT": "SGT", "NZDT": "NZDT", "GYT": "GYT", "LHDT": "LHDT", "EST": "EST", "CLT": "CLT", "NZST": "NZST", "ACDT": "ACDT", "WEZ": "WEZ", "WESZ": "WESZ", "HKST": "HKST", "CAT": "CAT", "AEST": "AEST", "CHAST": "CHAST", "ACWST": "ACWST", "VET": "VET", "JDT": "JDT", "ART": "ART", "WAST": "WAST", "AEDT": "AEDT", "CHADT": "CHADT", "TMST": "TMST", "HAT": "HAT", "EDT": "EDT", "MST": "MST", "HADT": "HADT", "CST": "CST", "HNT": "HNT", "WART": "WART", "WARST": "WARST", "CDT": "CDT", "AWDT": "AWDT", "HKT": "HKT", "PST": "PST", "MEZ": "MEZ", "WAT": "WAT", "SRT": "SRT", "WIT": "WIT", "UYST": "UYST", "ChST": "ChST", "∅∅∅": "∅∅∅", "LHST": "LHST", "OEZ": "OEZ", "ARST": "ARST", "SAST": "SAST", "JST": "JST", "AWST": "AWST", "COST": "COST", "AKDT": "AKDT", "UYT": "UYT", "WIB": "WIB"},
+		timezones:          map[string]string{"NZST": "NZST", "SAST": "SAST", "SGT": "SGT", "IST": "IST", "AKDT": "AKDT", "ACWST": "ACWST", "PDT": "PDT", "WITA": "WITA", "CLST": "CLST", "HKST": "HKST", "COT": "COT", "MST": "MST", "NZDT": "NZDT", "JST": "JST", "VET": "VET", "UYT": "UYT", "UYST": "UYST", "PST": "PST", "HAST": "HAST", "ChST": "ChST", "EAT": "EAT", "GYT": "GYT", "HKT": "HKT", "ECT": "ECT", "AWDT": "AWDT", "HAT": "HAT", "EST": "EST", "ADT": "ADT", "CST": "CST", "CDT": "CDT", "LHST": "LHST", "MESZ": "MESZ", "WIT": "WIT", "ART": "ART", "LHDT": "LHDT", "WIB": "WIB", "HNT": "HNT", "BOT": "BOT", "BT": "BT", "ACWDT": "ACWDT", "WEZ": "WEZ", "JDT": "JDT", "OESZ": "OESZ", "ACDT": "ACDT", "∅∅∅": "∅∅∅", "GMT": "GMT", "WAST": "WAST", "TMT": "TMT", "TMST": "TMST", "AST": "AST", "EDT": "EDT", "WARST": "WARST", "CHAST": "CHAST", "AEST": "AEST", "SRT": "SRT", "GFT": "GFT", "MDT": "MDT", "ARST": "ARST", "CHADT": "CHADT", "ACST": "ACST", "AWST": "AWST", "MYT": "MYT", "HADT": "HADT", "WART": "WART", "WESZ": "WESZ", "CLT": "CLT", "MEZ": "MEZ", "AKST": "AKST", "COST": "COST", "OEZ": "OEZ", "AEDT": "AEDT", "CAT": "CAT", "WAT": "WAT"},
 	}
 }
 
@@ -171,7 +171,8 @@ func (agq *agq_CM) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'agq_CM' and handles both Whole and Real numbers based on 'v'
-func (agq *agq_CM) FmtNumber(num float64, v uint64) (results string) {
+func (agq *agq_CM) FmtNumber(num float64, v uint64) string {
+
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(agq.decimal) + len(agq.group)*len(s[:len(s)-int(v)-1])/3
 	count := 0
@@ -191,7 +192,6 @@ func (agq *agq_CM) FmtNumber(num float64, v uint64) (results string) {
 				for j := len(agq.group) - 1; j >= 0; j-- {
 					b = append(b, agq.group[j])
 				}
-
 				count = 1
 			} else {
 				count++
@@ -202,9 +202,7 @@ func (agq *agq_CM) FmtNumber(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(agq.minus) - 1; j >= 0; j-- {
-			b = append(b, agq.minus[j])
-		}
+		b = append(b, agq.minus[0])
 	}
 
 	// reverse
@@ -212,13 +210,12 @@ func (agq *agq_CM) FmtNumber(num float64, v uint64) (results string) {
 		b[i], b[j] = b[j], b[i]
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'agq_CM' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (agq *agq_CM) FmtPercent(num float64, v uint64) (results string) {
+func (agq *agq_CM) FmtPercent(num float64, v uint64) string {
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(agq.decimal)
 	b := make([]byte, 0, l)
@@ -234,9 +231,7 @@ func (agq *agq_CM) FmtPercent(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(agq.minus) - 1; j >= 0; j-- {
-			b = append(b, agq.minus[j])
-		}
+		b = append(b, agq.minus[0])
 	}
 
 	// reverse
@@ -246,12 +241,11 @@ func (agq *agq_CM) FmtPercent(num float64, v uint64) (results string) {
 
 	b = append(b, agq.percent...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'agq_CM'
-func (agq *agq_CM) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (agq *agq_CM) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := agq.currencies[currency]
@@ -273,7 +267,6 @@ func (agq *agq_CM) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 				for j := len(agq.group) - 1; j >= 0; j-- {
 					b = append(b, agq.group[j])
 				}
-
 				count = 1
 			} else {
 				count++
@@ -284,9 +277,7 @@ func (agq *agq_CM) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 	}
 
 	if num < 0 {
-		for j := len(agq.minus) - 1; j >= 0; j-- {
-			b = append(b, agq.minus[j])
-		}
+		b = append(b, agq.minus[0])
 	}
 
 	// reverse
@@ -307,13 +298,12 @@ func (agq *agq_CM) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 
 	b = append(b, symbol...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'agq_CM'
 // in accounting notation.
-func (agq *agq_CM) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (agq *agq_CM) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := agq.currencies[currency]
@@ -335,7 +325,6 @@ func (agq *agq_CM) FmtAccounting(num float64, v uint64, currency currency.Type)
 				for j := len(agq.group) - 1; j >= 0; j-- {
 					b = append(b, agq.group[j])
 				}
-
 				count = 1
 			} else {
 				count++
@@ -347,9 +336,7 @@ func (agq *agq_CM) FmtAccounting(num float64, v uint64, currency currency.Type)
 
 	if num < 0 {
 
-		for j := len(agq.minus) - 1; j >= 0; j-- {
-			b = append(b, agq.minus[j])
-		}
+		b = append(b, agq.minus[0])
 
 	}
 
@@ -376,8 +363,7 @@ func (agq *agq_CM) FmtAccounting(num float64, v uint64, currency currency.Type)
 		b = append(b, symbol...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'agq_CM'

ak/ak.go

@@ -60,7 +60,7 @@ func New() locales.Translator {
 		erasAbbreviated:    []string{"AK", "KE"},
 		erasNarrow:         []string{"", ""},
 		erasWide:           []string{"Ansa Kristo", "Kristo Ekyiri"},
-		timezones:          map[string]string{"CST": "CST", "TMT": "TMT", "HKT": "HKT", "LHDT": "LHDT", "CDT": "CDT", "WART": "WART", "MESZ": "MESZ", "HADT": "HADT", "ARST": "ARST", "WIT": "WIT", "ChST": "ChST", "AKDT": "AKDT", "PST": "PST", "CHADT": "CHADT", "ACDT": "ACDT", "UYT": "UYT", "AEDT": "AEDT", "MST": "MST", "HKST": "HKST", "GFT": "GFT", "ACWDT": "ACWDT", "GMT": "GMT", "COT": "COT", "SRT": "SRT", "AST": "AST", "WEZ": "WEZ", "CLST": "CLST", "OEZ": "OEZ", "GYT": "GYT", "WAST": "WAST", "HNT": "HNT", "BT": "BT", "VET": "VET", "AWDT": "AWDT", "EDT": "EDT", "WARST": "WARST", "MDT": "MDT", "AEST": "AEST", "ACWST": "ACWST", "MYT": "MYT", "ADT": "ADT", "MEZ": "MEZ", "JDT": "JDT", "∅∅∅": "∅∅∅", "ECT": "ECT", "HAT": "HAT", "CHAST": "CHAST", "WAT": "WAT", "WESZ": "WESZ", "UYST": "UYST", "IST": "IST", "AKST": "AKST", "AWST": "AWST", "NZDT": "NZDT", "WIB": "WIB", "SAST": "SAST", "JST": "JST", "NZST": "NZST", "OESZ": "OESZ", "BOT": "BOT", "EST": "EST", "SGT": "SGT", "CAT": "CAT", "ACST": "ACST", "HAST": "HAST", "CLT": "CLT", "PDT": "PDT", "ART": "ART", "TMST": "TMST", "LHST": "LHST", "EAT": "EAT", "COST": "COST", "WITA": "WITA"},
+		timezones:          map[string]string{"WART": "WART", "HNT": "HNT", "∅∅∅": "∅∅∅", "GFT": "GFT", "CST": "CST", "EST": "EST", "CHADT": "CHADT", "ADT": "ADT", "WIT": "WIT", "AKST": "AKST", "AKDT": "AKDT", "CLT": "CLT", "AEST": "AEST", "HKST": "HKST", "ACST": "ACST", "HKT": "HKT", "MESZ": "MESZ", "ACDT": "ACDT", "TMST": "TMST", "BT": "BT", "ART": "ART", "WITA": "WITA", "HADT": "HADT", "COT": "COT", "ACWST": "ACWST", "SRT": "SRT", "AWST": "AWST", "LHDT": "LHDT", "VET": "VET", "AST": "AST", "SGT": "SGT", "HAST": "HAST", "MEZ": "MEZ", "OESZ": "OESZ", "CLST": "CLST", "JDT": "JDT", "AEDT": "AEDT", "GYT": "GYT", "UYST": "UYST", "COST": "COST", "LHST": "LHST", "MST": "MST", "WAST": "WAST", "CHAST": "CHAST", "NZST": "NZST", "NZDT": "NZDT", "UYT": "UYT", "CDT": "CDT", "AWDT": "AWDT", "TMT": "TMT", "WESZ": "WESZ", "PDT": "PDT", "ARST": "ARST", "SAST": "SAST", "MDT": "MDT", "WAT": "WAT", "OEZ": "OEZ", "MYT": "MYT", "PST": "PST", "BOT": "BOT", "WEZ": "WEZ", "ACWDT": "ACWDT", "WARST": "WARST", "IST": "IST", "HAT": "HAT", "CAT": "CAT", "ChST": "ChST", "EDT": "EDT", "EAT": "EAT", "JST": "JST", "GMT": "GMT", "ECT": "ECT", "WIB": "WIB"},
 	}
 }
 
@@ -177,20 +177,19 @@ func (ak *ak) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'ak' and handles both Whole and Real numbers based on 'v'
-func (ak *ak) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ak *ak) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'ak' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (ak *ak) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ak *ak) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'ak'
-func (ak *ak) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (ak *ak) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ak.currencies[currency]
@@ -224,9 +223,7 @@ func (ak *ak) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 	}
 
 	if num < 0 {
-		for j := len(ak.minus) - 1; j >= 0; j-- {
-			b = append(b, ak.minus[j])
-		}
+		b = append(b, ak.minus[0])
 	}
 
 	// reverse
@@ -245,13 +242,12 @@ func (ak *ak) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'ak'
 // in accounting notation.
-func (ak *ak) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (ak *ak) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ak.currencies[currency]
@@ -286,9 +282,7 @@ func (ak *ak) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 			b = append(b, symbol[j])
 		}
 
-		for j := len(ak.minus) - 1; j >= 0; j-- {
-			b = append(b, ak.minus[j])
-		}
+		b = append(b, ak.minus[0])
 
 	} else {
 
@@ -314,8 +308,7 @@ func (ak *ak) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'ak'

ak_GH/ak_GH.go

@@ -60,7 +60,7 @@ func New() locales.Translator {
 		erasAbbreviated:    []string{"AK", "KE"},
 		erasNarrow:         []string{"", ""},
 		erasWide:           []string{"Ansa Kristo", "Kristo Ekyiri"},
-		timezones:          map[string]string{"ACWST": "ACWST", "WIB": "WIB", "PST": "PST", "PDT": "PDT", "BOT": "BOT", "SRT": "SRT", "EAT": "EAT", "EDT": "EDT", "COT": "COT", "MST": "MST", "HAST": "HAST", "AWST": "AWST", "CST": "CST", "UYT": "UYT", "ART": "ART", "ACWDT": "ACWDT", "ChST": "ChST", "AWDT": "AWDT", "MESZ": "MESZ", "LHDT": "LHDT", "WEZ": "WEZ", "∅∅∅": "∅∅∅", "AKDT": "AKDT", "WESZ": "WESZ", "CHAST": "CHAST", "GYT": "GYT", "MEZ": "MEZ", "MDT": "MDT", "JDT": "JDT", "CLST": "CLST", "NZST": "NZST", "BT": "BT", "SAST": "SAST", "NZDT": "NZDT", "ACDT": "ACDT", "AST": "AST", "ECT": "ECT", "LHST": "LHST", "MYT": "MYT", "AKST": "AKST", "OEZ": "OEZ", "CHADT": "CHADT", "ACST": "ACST", "ARST": "ARST", "JST": "JST", "GFT": "GFT", "HADT": "HADT", "CAT": "CAT", "CLT": "CLT", "COST": "COST", "WART": "WART", "IST": "IST", "HAT": "HAT", "AEST": "AEST", "OESZ": "OESZ", "GMT": "GMT", "TMST": "TMST", "HNT": "HNT", "HKST": "HKST", "WARST": "WARST", "WAST": "WAST", "VET": "VET", "WITA": "WITA", "SGT": "SGT", "WIT": "WIT", "CDT": "CDT", "ADT": "ADT", "HKT": "HKT", "UYST": "UYST", "EST": "EST", "AEDT": "AEDT", "WAT": "WAT", "TMT": "TMT"},
+		timezones:          map[string]string{"∅∅∅": "∅∅∅", "UYT": "UYT", "COT": "COT", "MEZ": "MEZ", "ACDT": "ACDT", "SGT": "SGT", "HKT": "HKT", "UYST": "UYST", "LHDT": "LHDT", "JDT": "JDT", "HNT": "HNT", "ART": "ART", "EST": "EST", "HAST": "HAST", "NZST": "NZST", "GYT": "GYT", "TMST": "TMST", "AKDT": "AKDT", "AWST": "AWST", "GMT": "GMT", "CLT": "CLT", "AEST": "AEST", "PDT": "PDT", "CDT": "CDT", "WEZ": "WEZ", "WITA": "WITA", "WAT": "WAT", "WIB": "WIB", "OEZ": "OEZ", "CLST": "CLST", "WART": "WART", "HAT": "HAT", "BT": "BT", "ChST": "ChST", "ACWDT": "ACWDT", "CHADT": "CHADT", "MDT": "MDT", "EDT": "EDT", "HADT": "HADT", "CST": "CST", "ACWST": "ACWST", "CHAST": "CHAST", "JST": "JST", "MST": "MST", "SAST": "SAST", "EAT": "EAT", "OESZ": "OESZ", "ACST": "ACST", "WARST": "WARST", "WIT": "WIT", "WAST": "WAST", "ADT": "ADT", "HKST": "HKST", "CAT": "CAT", "GFT": "GFT", "TMT": "TMT", "AST": "AST", "AWDT": "AWDT", "MYT": "MYT", "ARST": "ARST", "SRT": "SRT", "COST": "COST", "WESZ": "WESZ", "LHST": "LHST", "NZDT": "NZDT", "MESZ": "MESZ", "AEDT": "AEDT", "VET": "VET", "PST": "PST", "IST": "IST", "BOT": "BOT", "ECT": "ECT", "AKST": "AKST"},
 	}
 }
 
@@ -177,20 +177,19 @@ func (ak *ak_GH) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'ak_GH' and handles both Whole and Real numbers based on 'v'
-func (ak *ak_GH) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ak *ak_GH) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'ak_GH' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (ak *ak_GH) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ak *ak_GH) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'ak_GH'
-func (ak *ak_GH) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (ak *ak_GH) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ak.currencies[currency]
@@ -224,9 +223,7 @@ func (ak *ak_GH) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 	}
 
 	if num < 0 {
-		for j := len(ak.minus) - 1; j >= 0; j-- {
-			b = append(b, ak.minus[j])
-		}
+		b = append(b, ak.minus[0])
 	}
 
 	// reverse
@@ -245,13 +242,12 @@ func (ak *ak_GH) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'ak_GH'
 // in accounting notation.
-func (ak *ak_GH) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (ak *ak_GH) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ak.currencies[currency]
@@ -286,9 +282,7 @@ func (ak *ak_GH) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 			b = append(b, symbol[j])
 		}
 
-		for j := len(ak.minus) - 1; j >= 0; j-- {
-			b = append(b, ak.minus[j])
-		}
+		b = append(b, ak.minus[0])
 
 	} else {
 
@@ -314,8 +308,7 @@ func (ak *ak_GH) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'ak_GH'

as/as.go

@@ -58,7 +58,7 @@ func New() locales.Translator {
 		daysWide:               []string{"দেওবাৰ", "সোমবাৰ", "মঙ্গলবাৰ", "বুধবাৰ", "বৃহষ্পতিবাৰ", "শুক্ৰবাৰ", "শনিবাৰ"},
 		periodsAbbreviated:     []string{"পূৰ্বাহ্ণ", "অপৰাহ্ণ"},
 		periodsWide:            []string{"পূৰ্বাহ্ণ", "অপৰাহ্ণ"},
-		timezones:              map[string]string{"AEST": "AEST", "NZST": "NZST", "PST": "PST", "CLT": "CLT", "SGT": "SGT", "MESZ": "MESZ", "WAT": "WAT", "HAST": "HAST", "VET": "VET", "HADT": "HADT", "EST": "EST", "UYT": "UYT", "ADT": "ADT", "WAST": "WAST", "MDT": "MDT", "LHDT": "LHDT", "CDT": "CDT", "HAT": "HAT", "GMT": "GMT", "ACDT": "ACDT", "JDT": "JDT", "CAT": "CAT", "WIB": "WIB", "AST": "AST", "HKST": "HKST", "WEZ": "WEZ", "BOT": "BOT", "ARST": "ARST", "ACWST": "ACWST", "NZDT": "NZDT", "UYST": "UYST", "COST": "COST", "MEZ": "MEZ", "CLST": "CLST", "HNT": "HNT", "EAT": "EAT", "ART": "ART", "WART": "WART", "ACWDT": "ACWDT", "LHST": "LHST", "AKDT": "AKDT", "IST": "ভাৰতীয় সময়", "OESZ": "OESZ", "WARST": "WARST", "MYT": "MYT", "WITA": "WITA", "∅∅∅": "∅∅∅", "AKST": "AKST", "HKT": "HKT", "EDT": "EDT", "OEZ": "OEZ", "CHAST": "CHAST", "MST": "MST", "SRT": "SRT", "BT": "BT", "ECT": "ECT", "WIT": "WIT", "CST": "CST", "AWST": "AWST", "PDT": "PDT", "ACST": "ACST", "ChST": "ChST", "CHADT": "CHADT", "GYT": "GYT", "TMT": "TMT", "WESZ": "WESZ", "COT": "COT", "JST": "JST", "AWDT": "AWDT", "AEDT": "AEDT", "TMST": "TMST", "SAST": "SAST", "GFT": "GFT"},
+		timezones:              map[string]string{"ECT": "ECT", "OEZ": "OEZ", "VET": "VET", "COST": "COST", "AEDT": "AEDT", "PST": "PST", "WIT": "WIT", "TMST": "TMST", "EST": "EST", "ACWDT": "ACWDT", "OESZ": "OESZ", "JST": "JST", "JDT": "JDT", "ACDT": "ACDT", "ARST": "ARST", "MESZ": "MESZ", "ACST": "ACST", "WIB": "WIB", "ChST": "ChST", "SAST": "SAST", "WAST": "WAST", "AEST": "AEST", "PDT": "PDT", "AWST": "AWST", "HNT": "HNT", "HKT": "HKT", "GYT": "GYT", "MYT": "MYT", "NZDT": "NZDT", "ACWST": "ACWST", "HAST": "HAST", "GFT": "GFT", "GMT": "GMT", "AKST": "AKST", "WESZ": "WESZ", "WART": "WART", "WARST": "WARST", "ADT": "ADT", "UYT": "UYT", "HAT": "HAT", "AWDT": "AWDT", "WAT": "WAT", "MST": "MST", "COT": "COT", "TMT": "TMT", "BT": "BT", "CAT": "CAT", "WITA": "WITA", "CST": "CST", "NZST": "NZST", "CLT": "CLT", "MEZ": "MEZ", "SGT": "SGT", "UYST": "UYST", "CHADT": "CHADT", "CLST": "CLST", "SRT": "SRT", "LHDT": "LHDT", "AKDT": "AKDT", "MDT": "MDT", "CDT": "CDT", "ART": "ART", "EDT": "EDT", "HADT": "HADT", "CHAST": "CHAST", "AST": "AST", "IST": "ভাৰতীয় সময়", "HKST": "HKST", "∅∅∅": "∅∅∅", "LHST": "LHST", "EAT": "EAT", "BOT": "BOT", "WEZ": "WEZ"},
 	}
 }
 
@@ -189,7 +189,8 @@ func (as *as) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'as' and handles both Whole and Real numbers based on 'v'
-func (as *as) FmtNumber(num float64, v uint64) (results string) {
+func (as *as) FmtNumber(num float64, v uint64) string {
+
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(as.decimal) + len(as.group)*len(s[:len(s)-int(v)-1])/3
 	count := 0
@@ -202,10 +203,7 @@ func (as *as) FmtNumber(num float64, v uint64) (results string) {
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(as.decimal) - 1; j >= 0; j-- {
-				b = append(b, as.decimal[j])
-			}
-
+			b = append(b, as.decimal[0])
 			inWhole = true
 			continue
 		}
@@ -213,10 +211,7 @@ func (as *as) FmtNumber(num float64, v uint64) (results string) {
 		if inWhole {
 
 			if count == groupThreshold {
-				for j := len(as.group) - 1; j >= 0; j-- {
-					b = append(b, as.group[j])
-				}
-
+				b = append(b, as.group[0])
 				count = 1
 
 				if !inSecondary {
@@ -232,9 +227,7 @@ func (as *as) FmtNumber(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(as.minus) - 1; j >= 0; j-- {
-			b = append(b, as.minus[j])
-		}
+		b = append(b, as.minus[0])
 	}
 
 	// reverse
@@ -242,13 +235,12 @@ func (as *as) FmtNumber(num float64, v uint64) (results string) {
 		b[i], b[j] = b[j], b[i]
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'as' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (as *as) FmtPercent(num float64, v uint64) (results string) {
+func (as *as) FmtPercent(num float64, v uint64) string {
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(as.decimal)
 	b := make([]byte, 0, l)
@@ -256,10 +248,7 @@ func (as *as) FmtPercent(num float64, v uint64) (results string) {
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(as.decimal) - 1; j >= 0; j-- {
-				b = append(b, as.decimal[j])
-			}
-
+			b = append(b, as.decimal[0])
 			continue
 		}
 
@@ -267,9 +256,7 @@ func (as *as) FmtPercent(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(as.minus) - 1; j >= 0; j-- {
-			b = append(b, as.minus[j])
-		}
+		b = append(b, as.minus[0])
 	}
 
 	// reverse
@@ -279,12 +266,11 @@ func (as *as) FmtPercent(num float64, v uint64) (results string) {
 
 	b = append(b, as.percent...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'as'
-func (as *as) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (as *as) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := as.currencies[currency]
@@ -299,10 +285,7 @@ func (as *as) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(as.decimal) - 1; j >= 0; j-- {
-				b = append(b, as.decimal[j])
-			}
-
+			b = append(b, as.decimal[0])
 			inWhole = true
 			continue
 		}
@@ -310,10 +293,7 @@ func (as *as) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 		if inWhole {
 
 			if count == groupThreshold {
-				for j := len(as.group) - 1; j >= 0; j-- {
-					b = append(b, as.group[j])
-				}
-
+				b = append(b, as.group[0])
 				count = 1
 
 				if !inSecondary {
@@ -337,9 +317,7 @@ func (as *as) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 	}
 
 	if num < 0 {
-		for j := len(as.minus) - 1; j >= 0; j-- {
-			b = append(b, as.minus[j])
-		}
+		b = append(b, as.minus[0])
 	}
 
 	// reverse
@@ -358,13 +336,12 @@ func (as *as) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'as'
 // in accounting notation.
-func (as *as) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (as *as) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := as.currencies[currency]
@@ -379,10 +356,7 @@ func (as *as) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(as.decimal) - 1; j >= 0; j-- {
-				b = append(b, as.decimal[j])
-			}
-
+			b = append(b, as.decimal[0])
 			inWhole = true
 			continue
 		}
@@ -390,10 +364,7 @@ func (as *as) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 		if inWhole {
 
 			if count == groupThreshold {
-				for j := len(as.group) - 1; j >= 0; j-- {
-					b = append(b, as.group[j])
-				}
-
+				b = append(b, as.group[0])
 				count = 1
 
 				if !inSecondary {
@@ -418,9 +389,7 @@ func (as *as) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 			b = append(b, as.currencyNegativePrefix[j])
 		}
 
-		for j := len(as.minus) - 1; j >= 0; j-- {
-			b = append(b, as.minus[j])
-		}
+		b = append(b, as.minus[0])
 
 	} else {
 
@@ -450,8 +419,7 @@ func (as *as) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'as'

as_IN/as_IN.go

@@ -58,7 +58,7 @@ func New() locales.Translator {
 		daysWide:               []string{"দেওবাৰ", "সোমবাৰ", "মঙ্গলবাৰ", "বুধবাৰ", "বৃহষ্পতিবাৰ", "শুক্ৰবাৰ", "শনিবাৰ"},
 		periodsAbbreviated:     []string{"পূৰ্বাহ্ণ", "অপৰাহ্ণ"},
 		periodsWide:            []string{"পূৰ্বাহ্ণ", "অপৰাহ্ণ"},
-		timezones:              map[string]string{"BT": "BT", "MDT": "MDT", "AKDT": "AKDT", "EAT": "EAT", "SAST": "SAST", "ACWDT": "ACWDT", "CAT": "CAT", "WARST": "WARST", "WAT": "WAT", "AST": "AST", "EDT": "EDT", "CHADT": "CHADT", "WAST": "WAST", "ECT": "ECT", "HADT": "HADT", "AWDT": "AWDT", "PST": "PST", "WIB": "WIB", "CHAST": "CHAST", "VET": "VET", "IST": "ভাৰতীয় সময়", "CLT": "CLT", "BOT": "BOT", "ACWST": "ACWST", "WIT": "WIT", "CLST": "CLST", "GMT": "GMT", "SRT": "SRT", "HKST": "HKST", "WEZ": "WEZ", "ADT": "ADT", "HAST": "HAST", "OEZ": "OEZ", "AEST": "AEST", "MEZ": "MEZ", "LHST": "LHST", "LHDT": "LHDT", "AEDT": "AEDT", "NZDT": "NZDT", "COT": "COT", "TMT": "TMT", "CST": "CST", "WESZ": "WESZ", "ART": "ART", "ARST": "ARST", "ACST": "ACST", "MYT": "MYT", "AWST": "AWST", "HNT": "HNT", "OESZ": "OESZ", "MST": "MST", "SGT": "SGT", "COST": "COST", "MESZ": "MESZ", "CDT": "CDT", "WART": "WART", "GFT": "GFT", "∅∅∅": "∅∅∅", "JST": "JST", "EST": "EST", "UYST": "UYST", "PDT": "PDT", "ACDT": "ACDT", "TMST": "TMST", "AKST": "AKST", "HKT": "HKT", "GYT": "GYT", "WITA": "WITA", "ChST": "ChST", "JDT": "JDT", "HAT": "HAT", "UYT": "UYT", "NZST": "NZST"},
+		timezones:              map[string]string{"WARST": "WARST", "VET": "VET", "ADT": "ADT", "GYT": "GYT", "ACWDT": "ACWDT", "ART": "ART", "WIB": "WIB", "SRT": "SRT", "HKT": "HKT", "UYT": "UYT", "CAT": "CAT", "GFT": "GFT", "IST": "ভাৰতীয় সময়", "HAST": "HAST", "ChST": "ChST", "ACWST": "ACWST", "PST": "PST", "EST": "EST", "WEZ": "WEZ", "WESZ": "WESZ", "LHDT": "LHDT", "EAT": "EAT", "JST": "JST", "ACST": "ACST", "MYT": "MYT", "GMT": "GMT", "BOT": "BOT", "JDT": "JDT", "WART": "WART", "SGT": "SGT", "WIT": "WIT", "BT": "BT", "CHAST": "CHAST", "AKST": "AKST", "OEZ": "OEZ", "AWST": "AWST", "EDT": "EDT", "CHADT": "CHADT", "WAT": "WAT", "MESZ": "MESZ", "PDT": "PDT", "HKST": "HKST", "TMT": "TMT", "MST": "MST", "CLT": "CLT", "AEDT": "AEDT", "AST": "AST", "MDT": "MDT", "WAST": "WAST", "CLST": "CLST", "∅∅∅": "∅∅∅", "WITA": "WITA", "AEST": "AEST", "ECT": "ECT", "LHST": "LHST", "NZST": "NZST", "NZDT": "NZDT", "AWDT": "AWDT", "ARST": "ARST", "COST": "COST", "HNT": "HNT", "HAT": "HAT", "TMST": "TMST", "MEZ": "MEZ", "CST": "CST", "CDT": "CDT", "COT": "COT", "AKDT": "AKDT", "SAST": "SAST", "OESZ": "OESZ", "ACDT": "ACDT", "HADT": "HADT", "UYST": "UYST"},
 	}
 }
 
@@ -189,7 +189,8 @@ func (as *as_IN) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'as_IN' and handles both Whole and Real numbers based on 'v'
-func (as *as_IN) FmtNumber(num float64, v uint64) (results string) {
+func (as *as_IN) FmtNumber(num float64, v uint64) string {
+
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(as.decimal) + len(as.group)*len(s[:len(s)-int(v)-1])/3
 	count := 0
@@ -202,10 +203,7 @@ func (as *as_IN) FmtNumber(num float64, v uint64) (results string) {
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(as.decimal) - 1; j >= 0; j-- {
-				b = append(b, as.decimal[j])
-			}
-
+			b = append(b, as.decimal[0])
 			inWhole = true
 			continue
 		}
@@ -213,10 +211,7 @@ func (as *as_IN) FmtNumber(num float64, v uint64) (results string) {
 		if inWhole {
 
 			if count == groupThreshold {
-				for j := len(as.group) - 1; j >= 0; j-- {
-					b = append(b, as.group[j])
-				}
-
+				b = append(b, as.group[0])
 				count = 1
 
 				if !inSecondary {
@@ -232,9 +227,7 @@ func (as *as_IN) FmtNumber(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(as.minus) - 1; j >= 0; j-- {
-			b = append(b, as.minus[j])
-		}
+		b = append(b, as.minus[0])
 	}
 
 	// reverse
@@ -242,13 +235,12 @@ func (as *as_IN) FmtNumber(num float64, v uint64) (results string) {
 		b[i], b[j] = b[j], b[i]
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'as_IN' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (as *as_IN) FmtPercent(num float64, v uint64) (results string) {
+func (as *as_IN) FmtPercent(num float64, v uint64) string {
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(as.decimal)
 	b := make([]byte, 0, l)
@@ -256,10 +248,7 @@ func (as *as_IN) FmtPercent(num float64, v uint64) (results string) {
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(as.decimal) - 1; j >= 0; j-- {
-				b = append(b, as.decimal[j])
-			}
-
+			b = append(b, as.decimal[0])
 			continue
 		}
 
@@ -267,9 +256,7 @@ func (as *as_IN) FmtPercent(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(as.minus) - 1; j >= 0; j-- {
-			b = append(b, as.minus[j])
-		}
+		b = append(b, as.minus[0])
 	}
 
 	// reverse
@@ -279,12 +266,11 @@ func (as *as_IN) FmtPercent(num float64, v uint64) (results string) {
 
 	b = append(b, as.percent...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'as_IN'
-func (as *as_IN) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (as *as_IN) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := as.currencies[currency]
@@ -299,10 +285,7 @@ func (as *as_IN) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(as.decimal) - 1; j >= 0; j-- {
-				b = append(b, as.decimal[j])
-			}
-
+			b = append(b, as.decimal[0])
 			inWhole = true
 			continue
 		}
@@ -310,10 +293,7 @@ func (as *as_IN) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 		if inWhole {
 
 			if count == groupThreshold {
-				for j := len(as.group) - 1; j >= 0; j-- {
-					b = append(b, as.group[j])
-				}
-
+				b = append(b, as.group[0])
 				count = 1
 
 				if !inSecondary {
@@ -337,9 +317,7 @@ func (as *as_IN) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 	}
 
 	if num < 0 {
-		for j := len(as.minus) - 1; j >= 0; j-- {
-			b = append(b, as.minus[j])
-		}
+		b = append(b, as.minus[0])
 	}
 
 	// reverse
@@ -358,13 +336,12 @@ func (as *as_IN) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'as_IN'
 // in accounting notation.
-func (as *as_IN) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (as *as_IN) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := as.currencies[currency]
@@ -379,10 +356,7 @@ func (as *as_IN) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(as.decimal) - 1; j >= 0; j-- {
-				b = append(b, as.decimal[j])
-			}
-
+			b = append(b, as.decimal[0])
 			inWhole = true
 			continue
 		}
@@ -390,10 +364,7 @@ func (as *as_IN) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 		if inWhole {
 
 			if count == groupThreshold {
-				for j := len(as.group) - 1; j >= 0; j-- {
-					b = append(b, as.group[j])
-				}
-
+				b = append(b, as.group[0])
 				count = 1
 
 				if !inSecondary {
@@ -418,9 +389,7 @@ func (as *as_IN) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 			b = append(b, as.currencyNegativePrefix[j])
 		}
 
-		for j := len(as.minus) - 1; j >= 0; j-- {
-			b = append(b, as.minus[j])
-		}
+		b = append(b, as.minus[0])
 
 	} else {
 
@@ -450,8 +419,7 @@ func (as *as_IN) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'as_IN'

asa/asa.go

@@ -63,7 +63,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"KM", "BM"},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"Kabla yakwe Yethu", "Baada yakwe Yethu"},
-		timezones:              map[string]string{"WART": "WART", "ADT": "ADT", "MEZ": "MEZ", "WIB": "WIB", "ART": "ART", "SRT": "SRT", "LHDT": "LHDT", "PDT": "PDT", "CHADT": "CHADT", "BOT": "BOT", "ACWDT": "ACWDT", "CDT": "CDT", "UYT": "UYT", "MST": "MST", "HAST": "HAST", "WESZ": "WESZ", "CST": "CST", "AEDT": "AEDT", "NZDT": "NZDT", "ACWST": "ACWST", "AKST": "AKST", "HADT": "HADT", "CHAST": "CHAST", "COST": "COST", "TMT": "TMT", "JDT": "JDT", "IST": "IST", "AWST": "AWST", "CLT": "CLT", "OEZ": "OEZ", "GYT": "GYT", "WITA": "WITA", "SGT": "SGT", "EAT": "EAT", "GMT": "GMT", "ACST": "ACST", "TMST": "TMST", "ARST": "ARST", "MESZ": "MESZ", "MDT": "MDT", "HKST": "HKST", "AEST": "AEST", "PST": "PST", "COT": "COT", "NZST": "NZST", "AWDT": "AWDT", "HAT": "HAT", "CAT": "CAT", "WARST": "WARST", "HNT": "HNT", "UYST": "UYST", "VET": "VET", "ACDT": "ACDT", "WAST": "WAST", "AST": "AST", "WIT": "WIT", "∅∅∅": "∅∅∅", "MYT": "MYT", "BT": "BT", "WEZ": "WEZ", "HKT": "HKT", "EST": "EST", "SAST": "SAST", "LHST": "LHST", "AKDT": "AKDT", "ECT": "ECT", "JST": "JST", "ChST": "ChST", "EDT": "EDT", "CLST": "CLST", "OESZ": "OESZ", "WAT": "WAT", "GFT": "GFT"},
+		timezones:              map[string]string{"EAT": "EAT", "AWDT": "AWDT", "CDT": "CDT", "CHAST": "CHAST", "AWST": "AWST", "UYT": "UYT", "UYST": "UYST", "HAST": "HAST", "EDT": "EDT", "WAST": "WAST", "IST": "IST", "SAST": "SAST", "JDT": "JDT", "AEDT": "AEDT", "CST": "CST", "AKST": "AKST", "ACWST": "ACWST", "WAT": "WAT", "CLT": "CLT", "SRT": "SRT", "COST": "COST", "ECT": "ECT", "MST": "MST", "MDT": "MDT", "LHST": "LHST", "HKST": "HKST", "TMST": "TMST", "BT": "BT", "WIB": "WIB", "WART": "WART", "WARST": "WARST", "WEZ": "WEZ", "JST": "JST", "HNT": "HNT", "HAT": "HAT", "BOT": "BOT", "GFT": "GFT", "GMT": "GMT", "CHADT": "CHADT", "OESZ": "OESZ", "ADT": "ADT", "CLST": "CLST", "WIT": "WIT", "NZST": "NZST", "GYT": "GYT", "ARST": "ARST", "HADT": "HADT", "COT": "COT", "ACWDT": "ACWDT", "LHDT": "LHDT", "EST": "EST", "ART": "ART", "AST": "AST", "SGT": "SGT", "CAT": "CAT", "HKT": "HKT", "ChST": "ChST", "MESZ": "MESZ", "VET": "VET", "ACST": "ACST", "PDT": "PDT", "∅∅∅": "∅∅∅", "MEZ": "MEZ", "AEST": "AEST", "MYT": "MYT", "OEZ": "OEZ", "ACDT": "ACDT", "PST": "PST", "WITA": "WITA", "TMT": "TMT", "AKDT": "AKDT", "WESZ": "WESZ", "NZDT": "NZDT"},
 	}
 }
 
@@ -180,20 +180,19 @@ func (asa *asa) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'asa' and handles both Whole and Real numbers based on 'v'
-func (asa *asa) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (asa *asa) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'asa' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (asa *asa) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (asa *asa) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'asa'
-func (asa *asa) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (asa *asa) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := asa.currencies[currency]
@@ -205,20 +204,14 @@ func (asa *asa) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(asa.decimal) - 1; j >= 0; j-- {
-				b = append(b, asa.decimal[j])
-			}
-
+			b = append(b, asa.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(asa.group) - 1; j >= 0; j-- {
-					b = append(b, asa.group[j])
-				}
-
+				b = append(b, asa.group[0])
 				count = 1
 			} else {
 				count++
@@ -229,9 +222,7 @@ func (asa *asa) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 	}
 
 	if num < 0 {
-		for j := len(asa.minus) - 1; j >= 0; j-- {
-			b = append(b, asa.minus[j])
-		}
+		b = append(b, asa.minus[0])
 	}
 
 	// reverse
@@ -254,13 +245,12 @@ func (asa *asa) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 
 	b = append(b, symbol...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'asa'
 // in accounting notation.
-func (asa *asa) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (asa *asa) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := asa.currencies[currency]
@@ -272,20 +262,14 @@ func (asa *asa) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(asa.decimal) - 1; j >= 0; j-- {
-				b = append(b, asa.decimal[j])
-			}
-
+			b = append(b, asa.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(asa.group) - 1; j >= 0; j-- {
-					b = append(b, asa.group[j])
-				}
-
+				b = append(b, asa.group[0])
 				count = 1
 			} else {
 				count++
@@ -297,9 +281,7 @@ func (asa *asa) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 
 	if num < 0 {
 
-		for j := len(asa.minus) - 1; j >= 0; j-- {
-			b = append(b, asa.minus[j])
-		}
+		b = append(b, asa.minus[0])
 
 	}
 
@@ -328,8 +310,7 @@ func (asa *asa) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 		b = append(b, symbol...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'asa'

asa_TZ/asa_TZ.go

@@ -63,7 +63,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"KM", "BM"},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"Kabla yakwe Yethu", "Baada yakwe Yethu"},
-		timezones:              map[string]string{"UYST": "UYST", "OEZ": "OEZ", "LHDT": "LHDT", "ECT": "ECT", "CDT": "CDT", "CLT": "CLT", "CHADT": "CHADT", "BOT": "BOT", "WEZ": "WEZ", "SAST": "SAST", "WIB": "WIB", "AEST": "AEST", "AEDT": "AEDT", "WAST": "WAST", "MESZ": "MESZ", "CHAST": "CHAST", "ART": "ART", "ACWST": "ACWST", "HADT": "HADT", "COT": "COT", "BT": "BT", "SRT": "SRT", "TMST": "TMST", "CLST": "CLST", "COST": "COST", "MDT": "MDT", "AKST": "AKST", "WESZ": "WESZ", "AWDT": "AWDT", "EDT": "EDT", "PST": "PST", "ACST": "ACST", "TMT": "TMT", "∅∅∅": "∅∅∅", "IST": "IST", "WARST": "WARST", "MEZ": "MEZ", "ACDT": "ACDT", "ChST": "ChST", "AWST": "AWST", "WART": "WART", "GFT": "GFT", "HAT": "HAT", "CAT": "CAT", "PDT": "PDT", "OESZ": "OESZ", "NZST": "NZST", "ARST": "ARST", "ACWDT": "ACWDT", "EST": "EST", "ADT": "ADT", "SGT": "SGT", "UYT": "UYT", "GYT": "GYT", "AST": "AST", "JDT": "JDT", "MYT": "MYT", "HNT": "HNT", "EAT": "EAT", "WITA": "WITA", "VET": "VET", "JST": "JST", "AKDT": "AKDT", "HAST": "HAST", "WAT": "WAT", "MST": "MST", "LHST": "LHST", "GMT": "GMT", "HKST": "HKST", "CST": "CST", "NZDT": "NZDT", "WIT": "WIT", "HKT": "HKT"},
+		timezones:              map[string]string{"AWDT": "AWDT", "CAT": "CAT", "TMST": "TMST", "JDT": "JDT", "CLST": "CLST", "ARST": "ARST", "HAST": "HAST", "GMT": "GMT", "WIB": "WIB", "HKST": "HKST", "WITA": "WITA", "AKDT": "AKDT", "OEZ": "OEZ", "PDT": "PDT", "NZST": "NZST", "CHADT": "CHADT", "HKT": "HKT", "AST": "AST", "ADT": "ADT", "HADT": "HADT", "MDT": "MDT", "WESZ": "WESZ", "WIT": "WIT", "MST": "MST", "ACWDT": "ACWDT", "NZDT": "NZDT", "HNT": "HNT", "TMT": "TMT", "ART": "ART", "∅∅∅": "∅∅∅", "ACWST": "ACWST", "WAST": "WAST", "MESZ": "MESZ", "OESZ": "OESZ", "WART": "WART", "AEST": "AEST", "EST": "EST", "COT": "COT", "SAST": "SAST", "WAT": "WAT", "AEDT": "AEDT", "BOT": "BOT", "ChST": "ChST", "LHDT": "LHDT", "ACST": "ACST", "CLT": "CLT", "IST": "IST", "SRT": "SRT", "CST": "CST", "WEZ": "WEZ", "MEZ": "MEZ", "PST": "PST", "BT": "BT", "GFT": "GFT", "LHST": "LHST", "EAT": "EAT", "MYT": "MYT", "GYT": "GYT", "AWST": "AWST", "UYST": "UYST", "EDT": "EDT", "ECT": "ECT", "ACDT": "ACDT", "SGT": "SGT", "JST": "JST", "WARST": "WARST", "HAT": "HAT", "CHAST": "CHAST", "VET": "VET", "UYT": "UYT", "CDT": "CDT", "AKST": "AKST", "COST": "COST"},
 	}
 }
 
@@ -180,20 +180,19 @@ func (asa *asa_TZ) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'asa_TZ' and handles both Whole and Real numbers based on 'v'
-func (asa *asa_TZ) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (asa *asa_TZ) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'asa_TZ' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (asa *asa_TZ) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (asa *asa_TZ) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'asa_TZ'
-func (asa *asa_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (asa *asa_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := asa.currencies[currency]
@@ -205,20 +204,14 @@ func (asa *asa_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(asa.decimal) - 1; j >= 0; j-- {
-				b = append(b, asa.decimal[j])
-			}
-
+			b = append(b, asa.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(asa.group) - 1; j >= 0; j-- {
-					b = append(b, asa.group[j])
-				}
-
+				b = append(b, asa.group[0])
 				count = 1
 			} else {
 				count++
@@ -229,9 +222,7 @@ func (asa *asa_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 	}
 
 	if num < 0 {
-		for j := len(asa.minus) - 1; j >= 0; j-- {
-			b = append(b, asa.minus[j])
-		}
+		b = append(b, asa.minus[0])
 	}
 
 	// reverse
@@ -254,13 +245,12 @@ func (asa *asa_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 
 	b = append(b, symbol...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'asa_TZ'
 // in accounting notation.
-func (asa *asa_TZ) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (asa *asa_TZ) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := asa.currencies[currency]
@@ -272,20 +262,14 @@ func (asa *asa_TZ) FmtAccounting(num float64, v uint64, currency currency.Type)
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(asa.decimal) - 1; j >= 0; j-- {
-				b = append(b, asa.decimal[j])
-			}
-
+			b = append(b, asa.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(asa.group) - 1; j >= 0; j-- {
-					b = append(b, asa.group[j])
-				}
-
+				b = append(b, asa.group[0])
 				count = 1
 			} else {
 				count++
@@ -297,9 +281,7 @@ func (asa *asa_TZ) FmtAccounting(num float64, v uint64, currency currency.Type)
 
 	if num < 0 {
 
-		for j := len(asa.minus) - 1; j >= 0; j-- {
-			b = append(b, asa.minus[j])
-		}
+		b = append(b, asa.minus[0])
 
 	}
 
@@ -328,8 +310,7 @@ func (asa *asa_TZ) FmtAccounting(num float64, v uint64, currency currency.Type)
 		b = append(b, symbol...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'asa_TZ'

bem/bem.go

@@ -61,7 +61,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"BC", "AD"},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"Before Yesu", "After Yesu"},
-		timezones:              map[string]string{"PST": "PST", "AEDT": "AEDT", "BOT": "BOT", "AWST": "AWST", "WITA": "WITA", "SAST": "SAST", "AWDT": "AWDT", "MST": "MST", "UYT": "UYT", "GMT": "GMT", "WART": "WART", "AST": "AST", "TMST": "TMST", "OESZ": "OESZ", "WAST": "WAST", "GFT": "GFT", "MYT": "MYT", "AKDT": "AKDT", "HAT": "HAT", "CAT": "CAT", "ARST": "ARST", "WARST": "WARST", "VET": "VET", "LHDT": "LHDT", "PDT": "PDT", "HKST": "HKST", "NZST": "NZST", "WAT": "WAT", "HADT": "HADT", "COT": "COT", "COST": "COST", "WEZ": "WEZ", "IST": "IST", "HKT": "HKT", "EAT": "EAT", "EST": "EST", "EDT": "EDT", "GYT": "GYT", "ADT": "ADT", "SRT": "SRT", "HNT": "HNT", "WESZ": "WESZ", "AEST": "AEST", "ACWDT": "ACWDT", "JST": "JST", "∅∅∅": "∅∅∅", "HAST": "HAST", "CLT": "CLT", "OEZ": "OEZ", "ACST": "ACST", "ART": "ART", "CDT": "CDT", "MEZ": "MEZ", "JDT": "JDT", "UYST": "UYST", "SGT": "SGT", "CST": "CST", "CLST": "CLST", "NZDT": "NZDT", "ACDT": "ACDT", "TMT": "TMT", "ACWST": "ACWST", "ChST": "ChST", "WIB": "WIB", "CHAST": "CHAST", "CHADT": "CHADT", "MESZ": "MESZ", "BT": "BT", "MDT": "MDT", "WIT": "WIT", "LHST": "LHST", "ECT": "ECT", "AKST": "AKST"},
+		timezones:              map[string]string{"TMST": "TMST", "EDT": "EDT", "WEZ": "WEZ", "LHST": "LHST", "WAST": "WAST", "OESZ": "OESZ", "CLST": "CLST", "MYT": "MYT", "CHADT": "CHADT", "JDT": "JDT", "OEZ": "OEZ", "VET": "VET", "EST": "EST", "COST": "COST", "WART": "WART", "GYT": "GYT", "CDT": "CDT", "WIB": "WIB", "WARST": "WARST", "COT": "COT", "EAT": "EAT", "HAT": "HAT", "HADT": "HADT", "MESZ": "MESZ", "AST": "AST", "PST": "PST", "LHDT": "LHDT", "NZST": "NZST", "PDT": "PDT", "AWST": "AWST", "CAT": "CAT", "WIT": "WIT", "ChST": "ChST", "CHAST": "CHAST", "HNT": "HNT", "MDT": "MDT", "ART": "ART", "HKST": "HKST", "GFT": "GFT", "HAST": "HAST", "JST": "JST", "MEZ": "MEZ", "ADT": "ADT", "AWDT": "AWDT", "BOT": "BOT", "GMT": "GMT", "ACST": "ACST", "CST": "CST", "SAST": "SAST", "ECT": "ECT", "WESZ": "WESZ", "UYT": "UYT", "AKST": "AKST", "AKDT": "AKDT", "SRT": "SRT", "UYST": "UYST", "HKT": "HKT", "CLT": "CLT", "ACDT": "ACDT", "AEST": "AEST", "WITA": "WITA", "TMT": "TMT", "BT": "BT", "ARST": "ARST", "ACWST": "ACWST", "MST": "MST", "IST": "IST", "∅∅∅": "∅∅∅", "ACWDT": "ACWDT", "WAT": "WAT", "AEDT": "AEDT", "SGT": "SGT", "NZDT": "NZDT"},
 	}
 }
 
@@ -178,20 +178,19 @@ func (bem *bem) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'bem' and handles both Whole and Real numbers based on 'v'
-func (bem *bem) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bem *bem) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'bem' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (bem *bem) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bem *bem) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'bem'
-func (bem *bem) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (bem *bem) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bem.currencies[currency]
@@ -203,20 +202,14 @@ func (bem *bem) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bem.decimal) - 1; j >= 0; j-- {
-				b = append(b, bem.decimal[j])
-			}
-
+			b = append(b, bem.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bem.group) - 1; j >= 0; j-- {
-					b = append(b, bem.group[j])
-				}
-
+				b = append(b, bem.group[0])
 				count = 1
 			} else {
 				count++
@@ -231,9 +224,7 @@ func (bem *bem) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 	}
 
 	if num < 0 {
-		for j := len(bem.minus) - 1; j >= 0; j-- {
-			b = append(b, bem.minus[j])
-		}
+		b = append(b, bem.minus[0])
 	}
 
 	// reverse
@@ -252,13 +243,12 @@ func (bem *bem) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'bem'
 // in accounting notation.
-func (bem *bem) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (bem *bem) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bem.currencies[currency]
@@ -270,20 +260,14 @@ func (bem *bem) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bem.decimal) - 1; j >= 0; j-- {
-				b = append(b, bem.decimal[j])
-			}
-
+			b = append(b, bem.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bem.group) - 1; j >= 0; j-- {
-					b = append(b, bem.group[j])
-				}
-
+				b = append(b, bem.group[0])
 				count = 1
 			} else {
 				count++
@@ -329,8 +313,7 @@ func (bem *bem) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 		b = append(b, bem.currencyNegativeSuffix...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'bem'

bem_ZM/bem_ZM.go

@@ -61,7 +61,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"BC", "AD"},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"Before Yesu", "After Yesu"},
-		timezones:              map[string]string{"SRT": "SRT", "LHDT": "LHDT", "MYT": "MYT", "HAST": "HAST", "HADT": "HADT", "GMT": "GMT", "CHADT": "CHADT", "MEZ": "MEZ", "WART": "WART", "AWST": "AWST", "HKST": "HKST", "OESZ": "OESZ", "ARST": "ARST", "AST": "AST", "JST": "JST", "JDT": "JDT", "AKDT": "AKDT", "MST": "MST", "EST": "EST", "BT": "BT", "WARST": "WARST", "WAT": "WAT", "HKT": "HKT", "EAT": "EAT", "ACST": "ACST", "ADT": "ADT", "WITA": "WITA", "ChST": "ChST", "SAST": "SAST", "AKST": "AKST", "WESZ": "WESZ", "AEST": "AEST", "OEZ": "OEZ", "WIT": "WIT", "WIB": "WIB", "ACDT": "ACDT", "ACWST": "ACWST", "AEDT": "AEDT", "COST": "COST", "GYT": "GYT", "UYT": "UYT", "EDT": "EDT", "CLT": "CLT", "SGT": "SGT", "∅∅∅": "∅∅∅", "UYST": "UYST", "COT": "COT", "TMST": "TMST", "CDT": "CDT", "NZST": "NZST", "TMT": "TMT", "HAT": "HAT", "CLST": "CLST", "PST": "PST", "AWDT": "AWDT", "WAST": "WAST", "ACWDT": "ACWDT", "NZDT": "NZDT", "PDT": "PDT", "BOT": "BOT", "ART": "ART", "MESZ": "MESZ", "WEZ": "WEZ", "HNT": "HNT", "CST": "CST", "ECT": "ECT", "IST": "IST", "MDT": "MDT", "CHAST": "CHAST", "LHST": "LHST", "CAT": "CAT", "VET": "VET", "GFT": "GFT"},
+		timezones:              map[string]string{"AWDT": "AWDT", "HKT": "HKT", "WART": "WART", "PDT": "PDT", "UYT": "UYT", "CLST": "CLST", "SGT": "SGT", "WAST": "WAST", "VET": "VET", "PST": "PST", "AWST": "AWST", "WITA": "WITA", "ACWST": "ACWST", "LHST": "LHST", "CLT": "CLT", "ADT": "ADT", "ACDT": "ACDT", "GYT": "GYT", "MYT": "MYT", "BT": "BT", "MDT": "MDT", "OEZ": "OEZ", "COT": "COT", "CHAST": "CHAST", "HAT": "HAT", "ChST": "ChST", "WEZ": "WEZ", "NZST": "NZST", "GFT": "GFT", "AKST": "AKST", "OESZ": "OESZ", "UYST": "UYST", "WIT": "WIT", "TMT": "TMT", "AST": "AST", "AEST": "AEST", "AEDT": "AEDT", "BOT": "BOT", "HADT": "HADT", "EDT": "EDT", "ECT": "ECT", "CST": "CST", "GMT": "GMT", "WARST": "WARST", "SRT": "SRT", "ART": "ART", "ARST": "ARST", "HAST": "HAST", "ACST": "ACST", "LHDT": "LHDT", "WAT": "WAT", "WIB": "WIB", "AKDT": "AKDT", "JDT": "JDT", "MEZ": "MEZ", "COST": "COST", "MESZ": "MESZ", "HNT": "HNT", "IST": "IST", "CAT": "CAT", "HKST": "HKST", "EST": "EST", "ACWDT": "ACWDT", "EAT": "EAT", "TMST": "TMST", "SAST": "SAST", "CHADT": "CHADT", "WESZ": "WESZ", "NZDT": "NZDT", "JST": "JST", "∅∅∅": "∅∅∅", "CDT": "CDT", "MST": "MST"},
 	}
 }
 
@@ -178,20 +178,19 @@ func (bem *bem_ZM) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'bem_ZM' and handles both Whole and Real numbers based on 'v'
-func (bem *bem_ZM) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bem *bem_ZM) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'bem_ZM' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (bem *bem_ZM) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bem *bem_ZM) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'bem_ZM'
-func (bem *bem_ZM) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (bem *bem_ZM) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bem.currencies[currency]
@@ -203,20 +202,14 @@ func (bem *bem_ZM) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bem.decimal) - 1; j >= 0; j-- {
-				b = append(b, bem.decimal[j])
-			}
-
+			b = append(b, bem.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bem.group) - 1; j >= 0; j-- {
-					b = append(b, bem.group[j])
-				}
-
+				b = append(b, bem.group[0])
 				count = 1
 			} else {
 				count++
@@ -231,9 +224,7 @@ func (bem *bem_ZM) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 	}
 
 	if num < 0 {
-		for j := len(bem.minus) - 1; j >= 0; j-- {
-			b = append(b, bem.minus[j])
-		}
+		b = append(b, bem.minus[0])
 	}
 
 	// reverse
@@ -252,13 +243,12 @@ func (bem *bem_ZM) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'bem_ZM'
 // in accounting notation.
-func (bem *bem_ZM) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (bem *bem_ZM) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bem.currencies[currency]
@@ -270,20 +260,14 @@ func (bem *bem_ZM) FmtAccounting(num float64, v uint64, currency currency.Type)
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bem.decimal) - 1; j >= 0; j-- {
-				b = append(b, bem.decimal[j])
-			}
-
+			b = append(b, bem.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bem.group) - 1; j >= 0; j-- {
-					b = append(b, bem.group[j])
-				}
-
+				b = append(b, bem.group[0])
 				count = 1
 			} else {
 				count++
@@ -329,8 +313,7 @@ func (bem *bem_ZM) FmtAccounting(num float64, v uint64, currency currency.Type)
 		b = append(b, bem.currencyNegativeSuffix...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'bem_ZM'

bez/bez.go

@@ -59,7 +59,7 @@ func New() locales.Translator {
 		erasAbbreviated:    []string{"KM", "BM"},
 		erasNarrow:         []string{"", ""},
 		erasWide:           []string{"Kabla ya Mtwaa", "Baada ya Mtwaa"},
-		timezones:          map[string]string{"WESZ": "WESZ", "CLT": "CLT", "AEDT": "AEDT", "WIT": "WIT", "HADT": "HADT", "MST": "MST", "AWDT": "AWDT", "HNT": "HNT", "CST": "CST", "CDT": "CDT", "OESZ": "OESZ", "BOT": "BOT", "CHADT": "CHADT", "SAST": "SAST", "HAST": "HAST", "HKST": "HKST", "∅∅∅": "∅∅∅", "BT": "BT", "AKDT": "AKDT", "SGT": "SGT", "TMT": "TMT", "AWST": "AWST", "ACWDT": "ACWDT", "GFT": "GFT", "EAT": "EAT", "CLST": "CLST", "UYT": "UYT", "CAT": "CAT", "NZDT": "NZDT", "COST": "COST", "WAT": "WAT", "MDT": "MDT", "NZST": "NZST", "COT": "COT", "MEZ": "MEZ", "WITA": "WITA", "TMST": "TMST", "AKST": "AKST", "EDT": "EDT", "ADT": "ADT", "GYT": "GYT", "ARST": "ARST", "WARST": "WARST", "GMT": "GMT", "PST": "PST", "CHAST": "CHAST", "LHDT": "LHDT", "SRT": "SRT", "WEZ": "WEZ", "HKT": "HKT", "EST": "EST", "MESZ": "MESZ", "ACDT": "ACDT", "ChST": "ChST", "IST": "IST", "HAT": "HAT", "AEST": "AEST", "PDT": "PDT", "AST": "AST", "WART": "WART", "ACWST": "ACWST", "MYT": "MYT", "WIB": "WIB", "VET": "VET", "ECT": "ECT", "JST": "JST", "LHST": "LHST", "UYST": "UYST", "OEZ": "OEZ", "ACST": "ACST", "ART": "ART", "WAST": "WAST", "JDT": "JDT"},
+		timezones:          map[string]string{"COST": "COST", "EAT": "EAT", "OEZ": "OEZ", "EST": "EST", "∅∅∅": "∅∅∅", "SAST": "SAST", "MST": "MST", "AEDT": "AEDT", "WARST": "WARST", "WESZ": "WESZ", "VET": "VET", "CAT": "CAT", "JST": "JST", "ADT": "ADT", "HAT": "HAT", "CDT": "CDT", "WAST": "WAST", "CHADT": "CHADT", "GFT": "GFT", "TMST": "TMST", "ECT": "ECT", "WEZ": "WEZ", "HNT": "HNT", "WIT": "WIT", "TMT": "TMT", "GMT": "GMT", "AKST": "AKST", "MEZ": "MEZ", "PST": "PST", "ARST": "ARST", "EDT": "EDT", "CHAST": "CHAST", "OESZ": "OESZ", "AEST": "AEST", "BOT": "BOT", "ART": "ART", "HADT": "HADT", "NZDT": "NZDT", "CLT": "CLT", "HKST": "HKST", "WAT": "WAT", "WART": "WART", "AWST": "AWST", "HKT": "HKT", "NZST": "NZST", "AST": "AST", "ACDT": "ACDT", "LHDT": "LHDT", "CLST": "CLST", "JDT": "JDT", "ACST": "ACST", "SRT": "SRT", "CST": "CST", "ACWST": "ACWST", "ACWDT": "ACWDT", "WIB": "WIB", "MESZ": "MESZ", "MYT": "MYT", "UYT": "UYT", "UYST": "UYST", "ChST": "ChST", "AKDT": "AKDT", "COT": "COT", "WITA": "WITA", "PDT": "PDT", "BT": "BT", "HAST": "HAST", "LHST": "LHST", "SGT": "SGT", "GYT": "GYT", "MDT": "MDT", "IST": "IST", "AWDT": "AWDT"},
 	}
 }
 
@@ -176,20 +176,19 @@ func (bez *bez) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'bez' and handles both Whole and Real numbers based on 'v'
-func (bez *bez) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bez *bez) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'bez' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (bez *bez) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bez *bez) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'bez'
-func (bez *bez) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (bez *bez) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bez.currencies[currency]
@@ -201,20 +200,14 @@ func (bez *bez) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bez.decimal) - 1; j >= 0; j-- {
-				b = append(b, bez.decimal[j])
-			}
-
+			b = append(b, bez.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bez.group) - 1; j >= 0; j-- {
-					b = append(b, bez.group[j])
-				}
-
+				b = append(b, bez.group[0])
 				count = 1
 			} else {
 				count++
@@ -225,9 +218,7 @@ func (bez *bez) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 	}
 
 	if num < 0 {
-		for j := len(bez.minus) - 1; j >= 0; j-- {
-			b = append(b, bez.minus[j])
-		}
+		b = append(b, bez.minus[0])
 	}
 
 	// reverse
@@ -248,13 +239,12 @@ func (bez *bez) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 
 	b = append(b, symbol...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'bez'
 // in accounting notation.
-func (bez *bez) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (bez *bez) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bez.currencies[currency]
@@ -266,20 +256,14 @@ func (bez *bez) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bez.decimal) - 1; j >= 0; j-- {
-				b = append(b, bez.decimal[j])
-			}
-
+			b = append(b, bez.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bez.group) - 1; j >= 0; j-- {
-					b = append(b, bez.group[j])
-				}
-
+				b = append(b, bez.group[0])
 				count = 1
 			} else {
 				count++
@@ -291,9 +275,7 @@ func (bez *bez) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 
 	if num < 0 {
 
-		for j := len(bez.minus) - 1; j >= 0; j-- {
-			b = append(b, bez.minus[j])
-		}
+		b = append(b, bez.minus[0])
 
 	}
 
@@ -320,8 +302,7 @@ func (bez *bez) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 		b = append(b, symbol...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'bez'

bez_TZ/bez_TZ.go

@@ -59,7 +59,7 @@ func New() locales.Translator {
 		erasAbbreviated:    []string{"KM", "BM"},
 		erasNarrow:         []string{"", ""},
 		erasWide:           []string{"Kabla ya Mtwaa", "Baada ya Mtwaa"},
-		timezones:          map[string]string{"JST": "JST", "AKDT": "AKDT", "UYST": "UYST", "EST": "EST", "EDT": "EDT", "ACST": "ACST", "MST": "MST", "WIT": "WIT", "WESZ": "WESZ", "HAT": "HAT", "WIB": "WIB", "GFT": "GFT", "TMST": "TMST", "JDT": "JDT", "HNT": "HNT", "CHADT": "CHADT", "MESZ": "MESZ", "BT": "BT", "ChST": "ChST", "WEZ": "WEZ", "OESZ": "OESZ", "ART": "ART", "ARST": "ARST", "NZST": "NZST", "COST": "COST", "ACDT": "ACDT", "EAT": "EAT", "IST": "IST", "AEDT": "AEDT", "PDT": "PDT", "COT": "COT", "WAT": "WAT", "ADT": "ADT", "HADT": "HADT", "AWDT": "AWDT", "UYT": "UYT", "OEZ": "OEZ", "∅∅∅": "∅∅∅", "LHST": "LHST", "HAST": "HAST", "SRT": "SRT", "SAST": "SAST", "AWST": "AWST", "BOT": "BOT", "LHDT": "LHDT", "MYT": "MYT", "ECT": "ECT", "HKT": "HKT", "HKST": "HKST", "NZDT": "NZDT", "CHAST": "CHAST", "WARST": "WARST", "WAST": "WAST", "ACWST": "ACWST", "CLT": "CLT", "GMT": "GMT", "AEST": "AEST", "GYT": "GYT", "WART": "WART", "ACWDT": "ACWDT", "CDT": "CDT", "MEZ": "MEZ", "MDT": "MDT", "SGT": "SGT", "AKST": "AKST", "CLST": "CLST", "CAT": "CAT", "WITA": "WITA", "TMT": "TMT", "CST": "CST", "PST": "PST", "AST": "AST", "VET": "VET"},
+		timezones:          map[string]string{"WAST": "WAST", "AEDT": "AEDT", "IST": "IST", "CST": "CST", "EAT": "EAT", "ChST": "ChST", "LHDT": "LHDT", "WEZ": "WEZ", "WESZ": "WESZ", "BT": "BT", "AKST": "AKST", "UYT": "UYT", "CDT": "CDT", "MEZ": "MEZ", "OEZ": "OEZ", "OESZ": "OESZ", "WIT": "WIT", "HKST": "HKST", "∅∅∅": "∅∅∅", "TMT": "TMT", "HAST": "HAST", "CLST": "CLST", "WARST": "WARST", "MYT": "MYT", "BOT": "BOT", "LHST": "LHST", "GYT": "GYT", "CAT": "CAT", "HKT": "HKT", "ACWDT": "ACWDT", "MST": "MST", "AWST": "AWST", "SAST": "SAST", "CHAST": "CHAST", "MESZ": "MESZ", "ACDT": "ACDT", "GFT": "GFT", "COST": "COST", "JDT": "JDT", "UYST": "UYST", "TMST": "TMST", "CHADT": "CHADT", "WART": "WART", "SGT": "SGT", "ART": "ART", "SRT": "SRT", "ARST": "ARST", "EDT": "EDT", "ACWST": "ACWST", "HAT": "HAT", "CLT": "CLT", "MDT": "MDT", "PDT": "PDT", "ECT": "ECT", "NZDT": "NZDT", "JST": "JST", "ADT": "ADT", "GMT": "GMT", "COT": "COT", "HNT": "HNT", "HADT": "HADT", "AKDT": "AKDT", "WAT": "WAT", "PST": "PST", "AWDT": "AWDT", "NZST": "NZST", "WIB": "WIB", "VET": "VET", "AST": "AST", "ACST": "ACST", "AEST": "AEST", "WITA": "WITA", "EST": "EST"},
 	}
 }
 
@@ -176,20 +176,19 @@ func (bez *bez_TZ) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'bez_TZ' and handles both Whole and Real numbers based on 'v'
-func (bez *bez_TZ) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bez *bez_TZ) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'bez_TZ' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (bez *bez_TZ) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bez *bez_TZ) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'bez_TZ'
-func (bez *bez_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (bez *bez_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bez.currencies[currency]
@@ -201,20 +200,14 @@ func (bez *bez_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bez.decimal) - 1; j >= 0; j-- {
-				b = append(b, bez.decimal[j])
-			}
-
+			b = append(b, bez.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bez.group) - 1; j >= 0; j-- {
-					b = append(b, bez.group[j])
-				}
-
+				b = append(b, bez.group[0])
 				count = 1
 			} else {
 				count++
@@ -225,9 +218,7 @@ func (bez *bez_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 	}
 
 	if num < 0 {
-		for j := len(bez.minus) - 1; j >= 0; j-- {
-			b = append(b, bez.minus[j])
-		}
+		b = append(b, bez.minus[0])
 	}
 
 	// reverse
@@ -248,13 +239,12 @@ func (bez *bez_TZ) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 
 	b = append(b, symbol...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'bez_TZ'
 // in accounting notation.
-func (bez *bez_TZ) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (bez *bez_TZ) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bez.currencies[currency]
@@ -266,20 +256,14 @@ func (bez *bez_TZ) FmtAccounting(num float64, v uint64, currency currency.Type)
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bez.decimal) - 1; j >= 0; j-- {
-				b = append(b, bez.decimal[j])
-			}
-
+			b = append(b, bez.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bez.group) - 1; j >= 0; j-- {
-					b = append(b, bez.group[j])
-				}
-
+				b = append(b, bez.group[0])
 				count = 1
 			} else {
 				count++
@@ -291,9 +275,7 @@ func (bez *bez_TZ) FmtAccounting(num float64, v uint64, currency currency.Type)
 
 	if num < 0 {
 
-		for j := len(bez.minus) - 1; j >= 0; j-- {
-			b = append(b, bez.minus[j])
-		}
+		b = append(b, bez.minus[0])
 
 	}
 
@@ -320,8 +302,7 @@ func (bez *bez_TZ) FmtAccounting(num float64, v uint64, currency currency.Type)
 		b = append(b, symbol...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'bez_TZ'

bm/bm.go

@@ -61,7 +61,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"J.-C. ɲɛ", "ni J.-C."},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"jezu krisiti ɲɛ", "jezu krisiti minkɛ"},
-		timezones:              map[string]string{"HAST": "HAST", "CST": "CST", "UYT": "UYT", "TMT": "TMT", "TMST": "TMST", "HAT": "HAT", "HKST": "HKST", "PDT": "PDT", "ARST": "ARST", "ADT": "ADT", "ART": "ART", "VET": "VET", "HNT": "HNT", "COT": "COT", "MEZ": "MEZ", "WART": "WART", "SGT": "SGT", "AKDT": "AKDT", "UYST": "UYST", "AEST": "AEST", "MESZ": "MESZ", "MYT": "MYT", "WIB": "WIB", "COST": "COST", "JST": "JST", "NZDT": "NZDT", "CLST": "CLST", "AKST": "AKST", "EAT": "EAT", "SRT": "SRT", "ACWST": "ACWST", "∅∅∅": "∅∅∅", "ChST": "ChST", "OESZ": "OESZ", "BT": "BT", "ACDT": "ACDT", "HADT": "HADT", "WEZ": "WEZ", "PST": "PST", "CHAST": "CHAST", "GYT": "GYT", "WAST": "WAST", "GFT": "GFT", "ECT": "ECT", "EDT": "EDT", "BOT": "BOT", "WARST": "WARST", "MST": "MST", "ACWDT": "ACWDT", "LHST": "LHST", "AWST": "AWST", "CDT": "CDT", "CLT": "CLT", "CAT": "CAT", "WAT": "WAT", "AST": "AST", "NZST": "NZST", "JDT": "JDT", "OEZ": "OEZ", "AWDT": "AWDT", "ACST": "ACST", "WESZ": "WESZ", "SAST": "SAST", "CHADT": "CHADT", "GMT": "GMT", "IST": "IST", "EST": "EST", "WIT": "WIT", "LHDT": "LHDT", "HKT": "HKT", "AEDT": "AEDT", "MDT": "MDT", "WITA": "WITA"},
+		timezones:              map[string]string{"MYT": "MYT", "WITA": "WITA", "WAT": "WAT", "WESZ": "WESZ", "ACWST": "ACWST", "WIB": "WIB", "ADT": "ADT", "WARST": "WARST", "ChST": "ChST", "GMT": "GMT", "WEZ": "WEZ", "MESZ": "MESZ", "JST": "JST", "AST": "AST", "HKT": "HKT", "WIT": "WIT", "EST": "EST", "EDT": "EDT", "AKST": "AKST", "∅∅∅": "∅∅∅", "OESZ": "OESZ", "AEST": "AEST", "SGT": "SGT", "AWST": "AWST", "UYT": "UYT", "CST": "CST", "COST": "COST", "LHST": "LHST", "MDT": "MDT", "AEDT": "AEDT", "PDT": "PDT", "CAT": "CAT", "HAST": "HAST", "CLT": "CLT", "PST": "PST", "HNT": "HNT", "GFT": "GFT", "SAST": "SAST", "JDT": "JDT", "WART": "WART", "VET": "VET", "IST": "IST", "BOT": "BOT", "MST": "MST", "ACWDT": "ACWDT", "CLST": "CLST", "AKDT": "AKDT", "ART": "ART", "CDT": "CDT", "MEZ": "MEZ", "HADT": "HADT", "LHDT": "LHDT", "OEZ": "OEZ", "WAST": "WAST", "TMST": "TMST", "ECT": "ECT", "EAT": "EAT", "CHADT": "CHADT", "ACDT": "ACDT", "UYST": "UYST", "NZDT": "NZDT", "SRT": "SRT", "CHAST": "CHAST", "HKST": "HKST", "TMT": "TMT", "ACST": "ACST", "AWDT": "AWDT", "GYT": "GYT", "COT": "COT", "NZST": "NZST", "HAT": "HAT", "BT": "BT", "ARST": "ARST"},
 	}
 }
 
@@ -171,20 +171,19 @@ func (bm *bm) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'bm' and handles both Whole and Real numbers based on 'v'
-func (bm *bm) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bm *bm) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'bm' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (bm *bm) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bm *bm) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'bm'
-func (bm *bm) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (bm *bm) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bm.currencies[currency]
@@ -196,20 +195,14 @@ func (bm *bm) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bm.decimal) - 1; j >= 0; j-- {
-				b = append(b, bm.decimal[j])
-			}
-
+			b = append(b, bm.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bm.group) - 1; j >= 0; j-- {
-					b = append(b, bm.group[j])
-				}
-
+				b = append(b, bm.group[0])
 				count = 1
 			} else {
 				count++
@@ -224,9 +217,7 @@ func (bm *bm) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 	}
 
 	if num < 0 {
-		for j := len(bm.minus) - 1; j >= 0; j-- {
-			b = append(b, bm.minus[j])
-		}
+		b = append(b, bm.minus[0])
 	}
 
 	// reverse
@@ -245,13 +236,12 @@ func (bm *bm) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'bm'
 // in accounting notation.
-func (bm *bm) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (bm *bm) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bm.currencies[currency]
@@ -263,20 +253,14 @@ func (bm *bm) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bm.decimal) - 1; j >= 0; j-- {
-				b = append(b, bm.decimal[j])
-			}
-
+			b = append(b, bm.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bm.group) - 1; j >= 0; j-- {
-					b = append(b, bm.group[j])
-				}
-
+				b = append(b, bm.group[0])
 				count = 1
 			} else {
 				count++
@@ -322,8 +306,7 @@ func (bm *bm) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 		b = append(b, bm.currencyNegativeSuffix...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'bm'

bm_ML/bm_ML.go

@@ -61,7 +61,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"J.-C. ɲɛ", "ni J.-C."},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"jezu krisiti ɲɛ", "jezu krisiti minkɛ"},
-		timezones:              map[string]string{"HAST": "HAST", "NZST": "NZST", "VET": "VET", "SRT": "SRT", "ChST": "ChST", "IST": "IST", "AKST": "AKST", "GMT": "GMT", "BT": "BT", "JDT": "JDT", "HKST": "HKST", "WIB": "WIB", "HNT": "HNT", "EAT": "EAT", "AWST": "AWST", "AEST": "AEST", "LHST": "LHST", "PDT": "PDT", "ECT": "ECT", "SGT": "SGT", "WESZ": "WESZ", "ARST": "ARST", "ACWDT": "ACWDT", "MST": "MST", "EDT": "EDT", "AST": "AST", "TMT": "TMT", "ACWST": "ACWST", "WIT": "WIT", "AWDT": "AWDT", "NZDT": "NZDT", "WAT": "WAT", "WAST": "WAST", "MDT": "MDT", "WEZ": "WEZ", "LHDT": "LHDT", "CLST": "CLST", "CHAST": "CHAST", "GYT": "GYT", "HKT": "HKT", "COT": "COT", "WARST": "WARST", "ADT": "ADT", "TMST": "TMST", "ACST": "ACST", "WITA": "WITA", "SAST": "SAST", "∅∅∅": "∅∅∅", "HADT": "HADT", "HAT": "HAT", "CDT": "CDT", "ART": "ART", "MYT": "MYT", "CAT": "CAT", "EST": "EST", "COST": "COST", "GFT": "GFT", "JST": "JST", "AEDT": "AEDT", "MEZ": "MEZ", "MESZ": "MESZ", "ACDT": "ACDT", "UYST": "UYST", "PST": "PST", "OEZ": "OEZ", "BOT": "BOT", "WART": "WART", "CHADT": "CHADT", "AKDT": "AKDT", "CST": "CST", "CLT": "CLT", "UYT": "UYT", "OESZ": "OESZ"},
+		timezones:              map[string]string{"TMT": "TMT", "GMT": "GMT", "ACDT": "ACDT", "AEDT": "AEDT", "GFT": "GFT", "ChST": "ChST", "ECT": "ECT", "MST": "MST", "OEZ": "OEZ", "JST": "JST", "PST": "PST", "COT": "COT", "SAST": "SAST", "WAT": "WAT", "WIB": "WIB", "OESZ": "OESZ", "CLST": "CLST", "BOT": "BOT", "UYT": "UYT", "ACWST": "ACWST", "LHST": "LHST", "NZST": "NZST", "ARST": "ARST", "NZDT": "NZDT", "HKT": "HKT", "WARST": "WARST", "MYT": "MYT", "HAST": "HAST", "COST": "COST", "MDT": "MDT", "ACST": "ACST", "HADT": "HADT", "WEZ": "WEZ", "ADT": "ADT", "HNT": "HNT", "BT": "BT", "EAT": "EAT", "WART": "WART", "AWDT": "AWDT", "HKST": "HKST", "WAST": "WAST", "SGT": "SGT", "AWST": "AWST", "VET": "VET", "GYT": "GYT", "TMST": "TMST", "ACWDT": "ACWDT", "JDT": "JDT", "CHAST": "CHAST", "CAT": "CAT", "AKDT": "AKDT", "∅∅∅": "∅∅∅", "WESZ": "WESZ", "MESZ": "MESZ", "WIT": "WIT", "CDT": "CDT", "EDT": "EDT", "CHADT": "CHADT", "AST": "AST", "WITA": "WITA", "EST": "EST", "AKST": "AKST", "CST": "CST", "CLT": "CLT", "SRT": "SRT", "AEST": "AEST", "PDT": "PDT", "UYST": "UYST", "IST": "IST", "HAT": "HAT", "ART": "ART", "LHDT": "LHDT", "MEZ": "MEZ"},
 	}
 }
 
@@ -171,20 +171,19 @@ func (bm *bm_ML) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'bm_ML' and handles both Whole and Real numbers based on 'v'
-func (bm *bm_ML) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bm *bm_ML) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'bm_ML' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (bm *bm_ML) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (bm *bm_ML) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'bm_ML'
-func (bm *bm_ML) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (bm *bm_ML) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bm.currencies[currency]
@@ -196,20 +195,14 @@ func (bm *bm_ML) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bm.decimal) - 1; j >= 0; j-- {
-				b = append(b, bm.decimal[j])
-			}
-
+			b = append(b, bm.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bm.group) - 1; j >= 0; j-- {
-					b = append(b, bm.group[j])
-				}
-
+				b = append(b, bm.group[0])
 				count = 1
 			} else {
 				count++
@@ -224,9 +217,7 @@ func (bm *bm_ML) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 	}
 
 	if num < 0 {
-		for j := len(bm.minus) - 1; j >= 0; j-- {
-			b = append(b, bm.minus[j])
-		}
+		b = append(b, bm.minus[0])
 	}
 
 	// reverse
@@ -245,13 +236,12 @@ func (bm *bm_ML) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'bm_ML'
 // in accounting notation.
-func (bm *bm_ML) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (bm *bm_ML) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bm.currencies[currency]
@@ -263,20 +253,14 @@ func (bm *bm_ML) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(bm.decimal) - 1; j >= 0; j-- {
-				b = append(b, bm.decimal[j])
-			}
-
+			b = append(b, bm.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(bm.group) - 1; j >= 0; j-- {
-					b = append(b, bm.group[j])
-				}
-
+				b = append(b, bm.group[0])
 				count = 1
 			} else {
 				count++
@@ -322,8 +306,7 @@ func (bm *bm_ML) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 		b = append(b, bm.currencyNegativeSuffix...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'bm_ML'

bo/bo.go

@@ -64,7 +64,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"སྤྱི་ལོ་སྔོན་", "སྤྱི་ལོ་"},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"", ""},
-		timezones:              map[string]string{"HKT": "HKT", "WIB": "WIB", "VET": "VET", "LHST": "LHST", "SRT": "SRT", "MYT": "MYT", "∅∅∅": "∅∅∅", "NZDT": "NZDT", "BT": "BT", "ACDT": "ACDT", "GYT": "GYT", "AST": "AST", "IST": "IST", "CDT": "CDT", "AEST": "AEST", "WIT": "WIT", "BOT": "BOT", "TMST": "TMST", "LHDT": "LHDT", "CHAST": "CHAST", "WAST": "WAST", "JST": "JST", "HAST": "HAST", "HAT": "HAT", "HKST": "HKST", "GMT": "GMT", "OESZ": "OESZ", "UYT": "UYT", "PDT": "PDT", "AKDT": "AKDT", "CLT": "CLT", "CLST": "CLST", "NZST": "NZST", "ECT": "ECT", "COST": "COST", "MEZ": "MEZ", "ACWST": "ACWST", "SGT": "SGT", "WESZ": "WESZ", "HNT": "HNT", "CAT": "CAT", "WITA": "WITA", "ChST": "ChST", "HADT": "HADT", "UYST": "UYST", "CHADT": "CHADT", "MESZ": "MESZ", "WARST": "WARST", "WAT": "WAT", "WEZ": "WEZ", "EST": "EST", "OEZ": "OEZ", "ART": "ART", "CST": "CST", "WART": "WART", "JDT": "JDT", "TMT": "TMT", "ACWDT": "ACWDT", "COT": "COT", "ARST": "ARST", "GFT": "GFT", "MDT": "MDT", "AWDT": "AWDT", "AEDT": "AEDT", "PST": "PST", "ACST": "ACST", "ADT": "ADT", "SAST": "SAST", "AKST": "AKST", "MST": "MST", "AWST": "AWST", "EAT": "EAT", "EDT": "EDT"},
+		timezones:              map[string]string{"CLST": "CLST", "MYT": "MYT", "BOT": "BOT", "CAT": "CAT", "JST": "JST", "EDT": "EDT", "GMT": "GMT", "AKST": "AKST", "COT": "COT", "WAST": "WAST", "WESZ": "WESZ", "MESZ": "MESZ", "OESZ": "OESZ", "JDT": "JDT", "WITA": "WITA", "CST": "CST", "HADT": "HADT", "NZST": "NZST", "EAT": "EAT", "MEZ": "MEZ", "WARST": "WARST", "OEZ": "OEZ", "SGT": "SGT", "AWDT": "AWDT", "HAST": "HAST", "WAT": "WAT", "GYT": "GYT", "CHADT": "CHADT", "PDT": "PDT", "HKST": "HKST", "TMT": "TMT", "ACWST": "ACWST", "WART": "WART", "HKT": "HKT", "NZDT": "NZDT", "VET": "VET", "UYT": "UYT", "ARST": "ARST", "GFT": "GFT", "ChST": "ChST", "ECT": "ECT", "MDT": "MDT", "CHAST": "CHAST", "EST": "EST", "AWST": "AWST", "BT": "BT", "ACWDT": "ACWDT", "AEST": "AEST", "IST": "IST", "HAT": "HAT", "TMST": "TMST", "CDT": "CDT", "COST": "COST", "WEZ": "WEZ", "CLT": "CLT", "AST": "AST", "ACST": "ACST", "ACDT": "ACDT", "PST": "PST", "ART": "ART", "LHDT": "LHDT", "∅∅∅": "∅∅∅", "AKDT": "AKDT", "MST": "MST", "SRT": "SRT", "UYST": "UYST", "WIT": "WIT", "LHST": "LHST", "SAST": "SAST", "WIB": "WIB", "ADT": "ADT", "AEDT": "AEDT", "HNT": "HNT"},
 	}
 }
 
@@ -174,7 +174,8 @@ func (bo *bo) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'bo' and handles both Whole and Real numbers based on 'v'
-func (bo *bo) FmtNumber(num float64, v uint64) (results string) {
+func (bo *bo) FmtNumber(num float64, v uint64) string {
+
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(bo.decimal) + len(bo.group)*len(s[:len(s)-int(v)-1])/3
 	count := 0
@@ -202,9 +203,7 @@ func (bo *bo) FmtNumber(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 	}
 
 	// reverse
@@ -212,13 +211,12 @@ func (bo *bo) FmtNumber(num float64, v uint64) (results string) {
 		b[i], b[j] = b[j], b[i]
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'bo' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (bo *bo) FmtPercent(num float64, v uint64) (results string) {
+func (bo *bo) FmtPercent(num float64, v uint64) string {
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(bo.decimal)
 	b := make([]byte, 0, l)
@@ -234,9 +232,7 @@ func (bo *bo) FmtPercent(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 	}
 
 	// reverse
@@ -246,12 +242,11 @@ func (bo *bo) FmtPercent(num float64, v uint64) (results string) {
 
 	b = append(b, bo.percent...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'bo'
-func (bo *bo) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (bo *bo) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bo.currencies[currency]
@@ -289,9 +284,7 @@ func (bo *bo) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 	}
 
 	if num < 0 {
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 	}
 
 	// reverse
@@ -310,13 +303,12 @@ func (bo *bo) FmtCurrency(num float64, v uint64, currency currency.Type) (result
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'bo'
 // in accounting notation.
-func (bo *bo) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (bo *bo) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bo.currencies[currency]
@@ -355,9 +347,7 @@ func (bo *bo) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 			b = append(b, bo.currencyNegativePrefix[j])
 		}
 
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 
 	} else {
 
@@ -387,8 +377,7 @@ func (bo *bo) FmtAccounting(num float64, v uint64, currency currency.Type) (resu
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'bo'

bo_CN/bo_CN.go

@@ -64,7 +64,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"སྤྱི་ལོ་སྔོན་", "སྤྱི་ལོ་"},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"", ""},
-		timezones:              map[string]string{"BOT": "BOT", "LHDT": "LHDT", "ChST": "ChST", "CLST": "CLST", "WIB": "WIB", "ACST": "ACST", "CLT": "CLT", "GMT": "GMT", "LHST": "LHST", "ECT": "ECT", "WIT": "WIT", "CDT": "CDT", "HKT": "HKT", "AST": "AST", "SRT": "SRT", "WITA": "WITA", "SGT": "SGT", "OESZ": "OESZ", "EAT": "EAT", "AEST": "AEST", "CHAST": "CHAST", "ADT": "ADT", "∅∅∅": "∅∅∅", "AKDT": "AKDT", "EDT": "EDT", "WAT": "WAT", "WESZ": "WESZ", "HNT": "HNT", "WAST": "WAST", "MEZ": "MEZ", "ACWDT": "ACWDT", "GFT": "GFT", "UYT": "UYT", "ARST": "ARST", "MDT": "MDT", "WEZ": "WEZ", "UYST": "UYST", "WART": "WART", "MESZ": "MESZ", "BT": "BT", "HAST": "HAST", "CAT": "CAT", "PDT": "PDT", "GYT": "GYT", "VET": "VET", "JDT": "JDT", "HAT": "HAT", "EST": "EST", "NZST": "NZST", "ACWST": "ACWST", "IST": "IST", "HADT": "HADT", "AEDT": "AEDT", "COST": "COST", "ART": "ART", "SAST": "SAST", "OEZ": "OEZ", "WARST": "WARST", "ACDT": "ACDT", "MST": "MST", "TMT": "TMT", "TMST": "TMST", "MYT": "MYT", "CST": "CST", "NZDT": "NZDT", "JST": "JST", "AKST": "AKST", "AWST": "AWST", "PST": "PST", "CHADT": "CHADT", "COT": "COT", "AWDT": "AWDT", "HKST": "HKST"},
+		timezones:              map[string]string{"HADT": "HADT", "MST": "MST", "GYT": "GYT", "TMT": "TMT", "CDT": "CDT", "AST": "AST", "HNT": "HNT", "PST": "PST", "HKST": "HKST", "ECT": "ECT", "WAT": "WAT", "CHAST": "CHAST", "JST": "JST", "AKST": "AKST", "ACWST": "ACWST", "CLST": "CLST", "ART": "ART", "LHST": "LHST", "MEZ": "MEZ", "EST": "EST", "WIB": "WIB", "ACST": "ACST", "HAT": "HAT", "MYT": "MYT", "SRT": "SRT", "WITA": "WITA", "GFT": "GFT", "COT": "COT", "NZST": "NZST", "WARST": "WARST", "AEDT": "AEDT", "SGT": "SGT", "AKDT": "AKDT", "CLT": "CLT", "VET": "VET", "AWDT": "AWDT", "UYT": "UYT", "ADT": "ADT", "WEZ": "WEZ", "WESZ": "WESZ", "NZDT": "NZDT", "MESZ": "MESZ", "WART": "WART", "GMT": "GMT", "EAT": "EAT", "UYST": "UYST", "EDT": "EDT", "MDT": "MDT", "WIT": "WIT", "∅∅∅": "∅∅∅", "COST": "COST", "TMST": "TMST", "AWST": "AWST", "HKT": "HKT", "ARST": "ARST", "ChST": "ChST", "CST": "CST", "WAST": "WAST", "CHADT": "CHADT", "PDT": "PDT", "LHDT": "LHDT", "OEZ": "OEZ", "OESZ": "OESZ", "AEST": "AEST", "BOT": "BOT", "CAT": "CAT", "ACWDT": "ACWDT", "SAST": "SAST", "JDT": "JDT", "ACDT": "ACDT", "IST": "IST", "HAST": "HAST", "BT": "BT"},
 	}
 }
 
@@ -174,7 +174,8 @@ func (bo *bo_CN) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'bo_CN' and handles both Whole and Real numbers based on 'v'
-func (bo *bo_CN) FmtNumber(num float64, v uint64) (results string) {
+func (bo *bo_CN) FmtNumber(num float64, v uint64) string {
+
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(bo.decimal) + len(bo.group)*len(s[:len(s)-int(v)-1])/3
 	count := 0
@@ -202,9 +203,7 @@ func (bo *bo_CN) FmtNumber(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 	}
 
 	// reverse
@@ -212,13 +211,12 @@ func (bo *bo_CN) FmtNumber(num float64, v uint64) (results string) {
 		b[i], b[j] = b[j], b[i]
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'bo_CN' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (bo *bo_CN) FmtPercent(num float64, v uint64) (results string) {
+func (bo *bo_CN) FmtPercent(num float64, v uint64) string {
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(bo.decimal)
 	b := make([]byte, 0, l)
@@ -234,9 +232,7 @@ func (bo *bo_CN) FmtPercent(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 	}
 
 	// reverse
@@ -246,12 +242,11 @@ func (bo *bo_CN) FmtPercent(num float64, v uint64) (results string) {
 
 	b = append(b, bo.percent...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'bo_CN'
-func (bo *bo_CN) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (bo *bo_CN) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bo.currencies[currency]
@@ -289,9 +284,7 @@ func (bo *bo_CN) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 	}
 
 	if num < 0 {
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 	}
 
 	// reverse
@@ -310,13 +303,12 @@ func (bo *bo_CN) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'bo_CN'
 // in accounting notation.
-func (bo *bo_CN) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (bo *bo_CN) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bo.currencies[currency]
@@ -355,9 +347,7 @@ func (bo *bo_CN) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 			b = append(b, bo.currencyNegativePrefix[j])
 		}
 
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 
 	} else {
 
@@ -387,8 +377,7 @@ func (bo *bo_CN) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'bo_CN'

bo_IN/bo_IN.go

@@ -64,7 +64,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"སྤྱི་ལོ་སྔོན་", "སྤྱི་ལོ་"},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"", ""},
-		timezones:              map[string]string{"AWDT": "AWDT", "HAT": "HAT", "NZDT": "NZDT", "ADT": "ADT", "ACDT": "ACDT", "GYT": "GYT", "OESZ": "OESZ", "CHAST": "CHAST", "COT": "COT", "ACST": "ACST", "ACWDT": "ACWDT", "CLST": "CLST", "GMT": "GMT", "BT": "BT", "MDT": "MDT", "CLT": "CLT", "PDT": "PDT", "WART": "WART", "MYT": "MYT", "HAST": "HAST", "SAST": "SAST", "∅∅∅": "∅∅∅", "WIB": "WIB", "TMT": "TMT", "WESZ": "WESZ", "UYST": "UYST", "WAST": "WAST", "AST": "AST", "SGT": "SGT", "HKT": "HKT", "MST": "MST", "HADT": "HADT", "EST": "EST", "NZST": "NZST", "COST": "COST", "ACWST": "ACWST", "ChST": "ChST", "AKDT": "AKDT", "AWST": "AWST", "WAT": "WAT", "TMST": "TMST", "GFT": "GFT", "LHST": "LHST", "IST": "IST", "UYT": "UYT", "CHADT": "CHADT", "SRT": "SRT", "WEZ": "WEZ", "EDT": "EDT", "MEZ": "MEZ", "JST": "JST", "AKST": "AKST", "AEST": "AEST", "ARST": "ARST", "WIT": "WIT", "VET": "VET", "EAT": "EAT", "CST": "CST", "CAT": "CAT", "BOT": "BOT", "ART": "ART", "MESZ": "MESZ", "HNT": "HNT", "PST": "PST", "LHDT": "LHDT", "ECT": "ECT", "JDT": "JDT", "HKST": "HKST", "CDT": "CDT", "OEZ": "OEZ", "AEDT": "AEDT", "WARST": "WARST", "WITA": "WITA"},
+		timezones:              map[string]string{"ARST": "ARST", "HAST": "HAST", "AST": "AST", "WIT": "WIT", "ACWST": "ACWST", "JDT": "JDT", "COT": "COT", "GYT": "GYT", "UYST": "UYST", "CST": "CST", "AKDT": "AKDT", "WESZ": "WESZ", "CLST": "CLST", "MEZ": "MEZ", "PDT": "PDT", "AEST": "AEST", "ACST": "ACST", "CHADT": "CHADT", "HKT": "HKT", "∅∅∅": "∅∅∅", "ACWDT": "ACWDT", "WIB": "WIB", "VET": "VET", "MST": "MST", "UYT": "UYT", "WITA": "WITA", "TMST": "TMST", "COST": "COST", "EAT": "EAT", "MESZ": "MESZ", "ADT": "ADT", "SGT": "SGT", "AWDT": "AWDT", "CDT": "CDT", "ECT": "ECT", "WAT": "WAT", "JST": "JST", "AWST": "AWST", "ART": "ART", "BT": "BT", "EST": "EST", "EDT": "EDT", "CHAST": "CHAST", "WART": "WART", "HAT": "HAT", "TMT": "TMT", "AKST": "AKST", "WAST": "WAST", "HNT": "HNT", "SRT": "SRT", "IST": "IST", "LHST": "LHST", "ACDT": "ACDT", "MYT": "MYT", "WEZ": "WEZ", "GMT": "GMT", "GFT": "GFT", "LHDT": "LHDT", "NZST": "NZST", "OEZ": "OEZ", "CAT": "CAT", "BOT": "BOT", "HADT": "HADT", "SAST": "SAST", "NZDT": "NZDT", "OESZ": "OESZ", "WARST": "WARST", "PST": "PST", "AEDT": "AEDT", "CLT": "CLT", "HKST": "HKST", "ChST": "ChST", "MDT": "MDT"},
 	}
 }
 
@@ -174,7 +174,8 @@ func (bo *bo_IN) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'bo_IN' and handles both Whole and Real numbers based on 'v'
-func (bo *bo_IN) FmtNumber(num float64, v uint64) (results string) {
+func (bo *bo_IN) FmtNumber(num float64, v uint64) string {
+
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(bo.decimal) + len(bo.group)*len(s[:len(s)-int(v)-1])/3
 	count := 0
@@ -202,9 +203,7 @@ func (bo *bo_IN) FmtNumber(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 	}
 
 	// reverse
@@ -212,13 +211,12 @@ func (bo *bo_IN) FmtNumber(num float64, v uint64) (results string) {
 		b[i], b[j] = b[j], b[i]
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'bo_IN' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (bo *bo_IN) FmtPercent(num float64, v uint64) (results string) {
+func (bo *bo_IN) FmtPercent(num float64, v uint64) string {
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(bo.decimal)
 	b := make([]byte, 0, l)
@@ -234,9 +232,7 @@ func (bo *bo_IN) FmtPercent(num float64, v uint64) (results string) {
 	}
 
 	if num < 0 {
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 	}
 
 	// reverse
@@ -246,12 +242,11 @@ func (bo *bo_IN) FmtPercent(num float64, v uint64) (results string) {
 
 	b = append(b, bo.percent...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'bo_IN'
-func (bo *bo_IN) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (bo *bo_IN) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bo.currencies[currency]
@@ -289,9 +284,7 @@ func (bo *bo_IN) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 	}
 
 	if num < 0 {
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 	}
 
 	// reverse
@@ -310,13 +303,12 @@ func (bo *bo_IN) FmtCurrency(num float64, v uint64, currency currency.Type) (res
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'bo_IN'
 // in accounting notation.
-func (bo *bo_IN) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (bo *bo_IN) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := bo.currencies[currency]
@@ -355,9 +347,7 @@ func (bo *bo_IN) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 			b = append(b, bo.currencyNegativePrefix[j])
 		}
 
-		for j := len(bo.minus) - 1; j >= 0; j-- {
-			b = append(b, bo.minus[j])
-		}
+		b = append(b, bo.minus[0])
 
 	} else {
 
@@ -387,8 +377,7 @@ func (bo *bo_IN) FmtAccounting(num float64, v uint64, currency currency.Type) (r
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'bo_IN'

cgg/cgg.go

@@ -57,7 +57,7 @@ func New() locales.Translator {
 		erasAbbreviated:   []string{"BC", "AD"},
 		erasNarrow:        []string{"", ""},
 		erasWide:          []string{"Kurisito Atakaijire", "Kurisito Yaijire"},
-		timezones:         map[string]string{"∅∅∅": "∅∅∅", "ChST": "ChST", "HAT": "HAT", "OEZ": "OEZ", "BOT": "BOT", "WAT": "WAT", "SAST": "SAST", "ACWDT": "ACWDT", "WAST": "WAST", "VET": "VET", "WIB": "WIB", "GYT": "GYT", "AKDT": "AKDT", "AWST": "AWST", "MESZ": "MESZ", "ACST": "ACST", "WART": "WART", "ECT": "ECT", "PDT": "PDT", "WESZ": "WESZ", "UYT": "UYT", "NZST": "NZST", "NZDT": "NZDT", "CDT": "CDT", "PST": "PST", "COT": "COT", "SRT": "SRT", "MYT": "MYT", "HAST": "HAST", "WARST": "WARST", "TMT": "TMT", "CST": "CST", "TMST": "TMST", "EDT": "EDT", "ART": "ART", "WITA": "WITA", "HKT": "HKT", "CLST": "CLST", "CAT": "CAT", "AEST": "AEST", "OESZ": "OESZ", "AST": "AST", "LHDT": "LHDT", "WEZ": "WEZ", "HNT": "HNT", "ARST": "ARST", "CLT": "CLT", "GMT": "GMT", "JDT": "JDT", "HADT": "HADT", "AEDT": "AEDT", "CHAST": "CHAST", "CHADT": "CHADT", "GFT": "GFT", "ACWST": "ACWST", "AKST": "AKST", "HKST": "HKST", "BT": "BT", "ACDT": "ACDT", "ADT": "ADT", "LHST": "LHST", "SGT": "SGT", "AWDT": "AWDT", "EAT": "EAT", "UYST": "UYST", "COST": "COST", "MDT": "MDT", "WIT": "WIT", "JST": "JST", "EST": "EST", "MEZ": "MEZ", "MST": "MST", "IST": "IST"},
+		timezones:         map[string]string{"ACST": "ACST", "HKST": "HKST", "LHDT": "LHDT", "JST": "JST", "PDT": "PDT", "CLT": "CLT", "JDT": "JDT", "AWDT": "AWDT", "WITA": "WITA", "WAT": "WAT", "MDT": "MDT", "WEZ": "WEZ", "CHAST": "CHAST", "MYT": "MYT", "EAT": "EAT", "SAST": "SAST", "OEZ": "OEZ", "HKT": "HKT", "WIT": "WIT", "TMST": "TMST", "ACWDT": "ACWDT", "OESZ": "OESZ", "PST": "PST", "GYT": "GYT", "CAT": "CAT", "TMT": "TMT", "EST": "EST", "COT": "COT", "NZST": "NZST", "CHADT": "CHADT", "AEDT": "AEDT", "ART": "ART", "VET": "VET", "HNT": "HNT", "EDT": "EDT", "AKST": "AKST", "MST": "MST", "MEZ": "MEZ", "ADT": "ADT", "WARST": "WARST", "ChST": "ChST", "COST": "COST", "CLST": "CLST", "AWST": "AWST", "CDT": "CDT", "LHST": "LHST", "WAST": "WAST", "WESZ": "WESZ", "HAT": "HAT", "ARST": "ARST", "ECT": "ECT", "AEST": "AEST", "IST": "IST", "BT": "BT", "CST": "CST", "AST": "AST", "ACDT": "ACDT", "UYT": "UYT", "GMT": "GMT", "SRT": "SRT", "HAST": "HAST", "NZDT": "NZDT", "MESZ": "MESZ", "SGT": "SGT", "BOT": "BOT", "UYST": "UYST", "HADT": "HADT", "AKDT": "AKDT", "ACWST": "ACWST", "WIB": "WIB", "WART": "WART", "GFT": "GFT", "∅∅∅": "∅∅∅"},
 	}
 }
 
@@ -174,20 +174,19 @@ func (cgg *cgg) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'cgg' and handles both Whole and Real numbers based on 'v'
-func (cgg *cgg) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (cgg *cgg) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'cgg' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (cgg *cgg) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (cgg *cgg) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'cgg'
-func (cgg *cgg) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (cgg *cgg) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := cgg.currencies[currency]
@@ -199,20 +198,14 @@ func (cgg *cgg) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(cgg.decimal) - 1; j >= 0; j-- {
-				b = append(b, cgg.decimal[j])
-			}
-
+			b = append(b, cgg.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(cgg.group) - 1; j >= 0; j-- {
-					b = append(b, cgg.group[j])
-				}
-
+				b = append(b, cgg.group[0])
 				count = 1
 			} else {
 				count++
@@ -227,9 +220,7 @@ func (cgg *cgg) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 	}
 
 	if num < 0 {
-		for j := len(cgg.minus) - 1; j >= 0; j-- {
-			b = append(b, cgg.minus[j])
-		}
+		b = append(b, cgg.minus[0])
 	}
 
 	// reverse
@@ -248,13 +239,12 @@ func (cgg *cgg) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'cgg'
 // in accounting notation.
-func (cgg *cgg) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (cgg *cgg) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := cgg.currencies[currency]
@@ -266,20 +256,14 @@ func (cgg *cgg) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(cgg.decimal) - 1; j >= 0; j-- {
-				b = append(b, cgg.decimal[j])
-			}
-
+			b = append(b, cgg.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(cgg.group) - 1; j >= 0; j-- {
-					b = append(b, cgg.group[j])
-				}
-
+				b = append(b, cgg.group[0])
 				count = 1
 			} else {
 				count++
@@ -295,9 +279,7 @@ func (cgg *cgg) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 			b = append(b, symbol[j])
 		}
 
-		for j := len(cgg.minus) - 1; j >= 0; j-- {
-			b = append(b, cgg.minus[j])
-		}
+		b = append(b, cgg.minus[0])
 
 	} else {
 
@@ -323,8 +305,7 @@ func (cgg *cgg) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'cgg'

cgg_UG/cgg_UG.go

@@ -57,7 +57,7 @@ func New() locales.Translator {
 		erasAbbreviated:   []string{"BC", "AD"},
 		erasNarrow:        []string{"", ""},
 		erasWide:          []string{"Kurisito Atakaijire", "Kurisito Yaijire"},
-		timezones:         map[string]string{"SGT": "SGT", "CLST": "CLST", "OESZ": "OESZ", "WART": "WART", "ACDT": "ACDT", "LHST": "LHST", "LHDT": "LHDT", "JDT": "JDT", "UYT": "UYT", "GMT": "GMT", "CHADT": "CHADT", "MEZ": "MEZ", "MESZ": "MESZ", "JST": "JST", "HKT": "HKT", "AST": "AST", "AWST": "AWST", "CLT": "CLT", "MST": "MST", "WIB": "WIB", "BOT": "BOT", "ART": "ART", "ACST": "ACST", "MYT": "MYT", "ADT": "ADT", "TMT": "TMT", "VET": "VET", "GFT": "GFT", "WIT": "WIT", "OEZ": "OEZ", "WAST": "WAST", "ACWDT": "ACWDT", "WEZ": "WEZ", "CDT": "CDT", "AWDT": "AWDT", "AEDT": "AEDT", "WAT": "WAT", "BT": "BT", "WITA": "WITA", "ChST": "ChST", "AKDT": "AKDT", "CST": "CST", "WESZ": "WESZ", "PST": "PST", "NZST": "NZST", "SRT": "SRT", "SAST": "SAST", "∅∅∅": "∅∅∅", "IST": "IST", "AKST": "AKST", "HNT": "HNT", "CAT": "CAT", "EDT": "EDT", "PDT": "PDT", "WARST": "WARST", "GYT": "GYT", "EAT": "EAT", "UYST": "UYST", "CHAST": "CHAST", "COST": "COST", "MDT": "MDT", "ECT": "ECT", "ARST": "ARST", "TMST": "TMST", "HADT": "HADT", "HKST": "HKST", "HAT": "HAT", "COT": "COT", "ACWST": "ACWST", "HAST": "HAST", "EST": "EST", "AEST": "AEST", "NZDT": "NZDT"},
+		timezones:         map[string]string{"WIT": "WIT", "TMST": "TMST", "SGT": "SGT", "PST": "PST", "UYST": "UYST", "ARST": "ARST", "ChST": "ChST", "MDT": "MDT", "JST": "JST", "WARST": "WARST", "ACST": "ACST", "AEST": "AEST", "WART": "WART", "PDT": "PDT", "WITA": "WITA", "AKDT": "AKDT", "COST": "COST", "MEZ": "MEZ", "CDT": "CDT", "ACWDT": "ACWDT", "GMT": "GMT", "EDT": "EDT", "EST": "EST", "LHDT": "LHDT", "AST": "AST", "HKST": "HKST", "WIB": "WIB", "JDT": "JDT", "HAST": "HAST", "∅∅∅": "∅∅∅", "NZDT": "NZDT", "WAST": "WAST", "WEZ": "WEZ", "UYT": "UYT", "TMT": "TMT", "IST": "IST", "AKST": "AKST", "LHST": "LHST", "NZST": "NZST", "AEDT": "AEDT", "HKT": "HKT", "ART": "ART", "GFT": "GFT", "CST": "CST", "ECT": "ECT", "OEZ": "OEZ", "ADT": "ADT", "HADT": "HADT", "CHADT": "CHADT", "MESZ": "MESZ", "HAT": "HAT", "BOT": "BOT", "CAT": "CAT", "ACWST": "ACWST", "SAST": "SAST", "MST": "MST", "HNT": "HNT", "GYT": "GYT", "CHAST": "CHAST", "ACDT": "ACDT", "VET": "VET", "MYT": "MYT", "CLST": "CLST", "AWDT": "AWDT", "SRT": "SRT", "WESZ": "WESZ", "OESZ": "OESZ", "CLT": "CLT", "AWST": "AWST", "BT": "BT", "COT": "COT", "EAT": "EAT", "WAT": "WAT"},
 	}
 }
 
@@ -174,20 +174,19 @@ func (cgg *cgg_UG) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'cgg_UG' and handles both Whole and Real numbers based on 'v'
-func (cgg *cgg_UG) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (cgg *cgg_UG) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'cgg_UG' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (cgg *cgg_UG) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (cgg *cgg_UG) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'cgg_UG'
-func (cgg *cgg_UG) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (cgg *cgg_UG) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := cgg.currencies[currency]
@@ -199,20 +198,14 @@ func (cgg *cgg_UG) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(cgg.decimal) - 1; j >= 0; j-- {
-				b = append(b, cgg.decimal[j])
-			}
-
+			b = append(b, cgg.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(cgg.group) - 1; j >= 0; j-- {
-					b = append(b, cgg.group[j])
-				}
-
+				b = append(b, cgg.group[0])
 				count = 1
 			} else {
 				count++
@@ -227,9 +220,7 @@ func (cgg *cgg_UG) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 	}
 
 	if num < 0 {
-		for j := len(cgg.minus) - 1; j >= 0; j-- {
-			b = append(b, cgg.minus[j])
-		}
+		b = append(b, cgg.minus[0])
 	}
 
 	// reverse
@@ -248,13 +239,12 @@ func (cgg *cgg_UG) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'cgg_UG'
 // in accounting notation.
-func (cgg *cgg_UG) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (cgg *cgg_UG) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := cgg.currencies[currency]
@@ -266,20 +256,14 @@ func (cgg *cgg_UG) FmtAccounting(num float64, v uint64, currency currency.Type)
 	for i := len(s) - 1; i >= 0; i-- {
 
 		if s[i] == '.' {
-			for j := len(cgg.decimal) - 1; j >= 0; j-- {
-				b = append(b, cgg.decimal[j])
-			}
-
+			b = append(b, cgg.decimal[0])
 			inWhole = true
 			continue
 		}
 
 		if inWhole {
 			if count == 3 {
-				for j := len(cgg.group) - 1; j >= 0; j-- {
-					b = append(b, cgg.group[j])
-				}
-
+				b = append(b, cgg.group[0])
 				count = 1
 			} else {
 				count++
@@ -295,9 +279,7 @@ func (cgg *cgg_UG) FmtAccounting(num float64, v uint64, currency currency.Type)
 			b = append(b, symbol[j])
 		}
 
-		for j := len(cgg.minus) - 1; j >= 0; j-- {
-			b = append(b, cgg.minus[j])
-		}
+		b = append(b, cgg.minus[0])
 
 	} else {
 
@@ -323,8 +305,7 @@ func (cgg *cgg_UG) FmtAccounting(num float64, v uint64, currency currency.Type)
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'cgg_UG'

chr/chr.go

@@ -69,7 +69,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"ᎤᏓᎷᎸ", "ᎤᎶᏐᏅ"},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"Ꮟ ᏥᏌ ᎾᏕᎲᏍᎬᎾ", "ᎠᎩᏃᎮᎵᏓᏍᏗᏱ ᎠᏕᏘᏱᏍᎬ ᏱᎰᏩ ᏧᏓᏂᎸᎢᏍᏗ"},
-		timezones:              map[string]string{"CHADT": "CHADT", "WAST": "WAST", "MEZ": "MEZ", "ACDT": "ACDT", "WART": "WART", "TMT": "TMT", "AWST": "AWST", "CLST": "CLST", "ADT": "ADT", "WIT": "WIT", "CST": "ᎠᏰᎵ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "EST": "ᎧᎸᎬᎢᏗᏢ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "PST": "ᏭᏕᎵᎬ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "WAT": "WAT", "ACWST": "ACWST", "TMST": "TMST", "LHST": "LHST", "EAT": "EAT", "UYT": "UYT", "ACST": "ACST", "JST": "JST", "PDT": "ᏭᏕᎵᎬ ᎢᎦ ᎢᏳᏩᎪᏗ", "OESZ": "OESZ", "NZST": "NZST", "BOT": "BOT", "SGT": "SGT", "HNT": "HNT", "AEST": "AEST", "AEDT": "AEDT", "IST": "IST", "AKDT": "AKDT", "CAT": "CAT", "NZDT": "NZDT", "WIB": "WIB", "CHAST": "CHAST", "AST": "AST", "HADT": "HADT", "WARST": "WARST", "HAST": "HAST", "AWDT": "AWDT", "GMT": "ᎢᏤ ᎢᏳᏍᏗ ᎢᏳᏩᎪᏗ", "GYT": "GYT", "ART": "ART", "ACWDT": "ACWDT", "MST": "ᎣᏓᎸ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "MDT": "ᎣᏓᎸ ᎢᎦ ᎢᏳᏩᎪᏗ", "AKST": "AKST", "ECT": "ECT", "HKT": "HKT", "OEZ": "OEZ", "BT": "BT", "GFT": "GFT", "HKST": "HKST", "ARST": "ARST", "WEZ": "WEZ", "WITA": "WITA", "MYT": "MYT", "HAT": "HAT", "UYST": "UYST", "MESZ": "MESZ", "LHDT": "LHDT", "ChST": "ChST", "CLT": "CLT", "COT": "COT", "COST": "COST", "SAST": "SAST", "JDT": "JDT", "CDT": "ᎠᏰᎵ ᎢᎦ ᎢᏳᏩᎪᏗ", "WESZ": "WESZ", "EDT": "ᎧᎸᎬᎢᏗᏢ ᎢᎦ ᎢᏳᏩᎪᏗ", "SRT": "SRT", "VET": "VET", "∅∅∅": "∅∅∅"},
+		timezones:              map[string]string{"UYT": "UYT", "COST": "COST", "GFT": "GFT", "WITA": "WITA", "TMST": "TMST", "HAST": "HAST", "SAST": "SAST", "CHAST": "CHAST", "CLT": "CLT", "AST": "AST", "HAT": "HAT", "WIT": "WIT", "ECT": "ECT", "WAT": "WAT", "MDT": "MDT", "ACWDT": "ACWDT", "ACST": "ACST", "AEST": "AEST", "WART": "WART", "MYT": "MYT", "EST": "ᎧᎸᎬᎢᏗᏢ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "MST": "MST", "CHADT": "CHADT", "JDT": "JDT", "ACDT": "ACDT", "SGT": "SGT", "TMT": "TMT", "GMT": "ᎢᏤ ᎢᏳᏍᏗ ᎢᏳᏩᎪᏗ", "LHDT": "LHDT", "WIB": "WIB", "∅∅∅": "∅∅∅", "COT": "COT", "AWST": "AWST", "BOT": "BOT", "SRT": "SRT", "HKST": "HKST", "HADT": "HADT", "NZST": "NZST", "MEZ": "MEZ", "CLST": "CLST", "WEZ": "WEZ", "WESZ": "WESZ", "ACWST": "ACWST", "CST": "ᎠᏰᎵ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "WARST": "WARST", "PST": "ᏭᏕᎵᎬ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "HNT": "HNT", "ART": "ART", "ChST": "ChST", "IST": "IST", "CDT": "ᎠᏰᎵ ᎢᎦ ᎢᏳᏩᎪᏗ", "LHST": "LHST", "HKT": "HKT", "MESZ": "MESZ", "ADT": "ADT", "VET": "VET", "CAT": "CAT", "AKST": "AKST", "AKDT": "AKDT", "WAST": "WAST", "PDT": "ᏭᏕᎵᎬ ᎢᎦ ᎢᏳᏩᎪᏗ", "ARST": "ARST", "OEZ": "OEZ", "OESZ": "OESZ", "JST": "JST", "GYT": "GYT", "UYST": "UYST", "BT": "BT", "EDT": "ᎧᎸᎬᎢᏗᏢ ᎢᎦ ᎢᏳᏩᎪᏗ", "EAT": "EAT", "NZDT": "NZDT", "AEDT": "AEDT", "AWDT": "AWDT"},
 	}
 }
 
@@ -186,7 +186,8 @@ func (chr *chr) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'chr' and handles both Whole and Real numbers based on 'v'
-func (chr *chr) FmtNumber(num float64, v uint64) (results string) {
+func (chr *chr) FmtNumber(num float64, v uint64) string {
+
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(chr.decimal) + len(chr.group)*len(s[:len(s)-int(v)-1])/3
 	count := 0
@@ -222,13 +223,12 @@ func (chr *chr) FmtNumber(num float64, v uint64) (results string) {
 		b[i], b[j] = b[j], b[i]
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'chr' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (chr *chr) FmtPercent(num float64, v uint64) (results string) {
+func (chr *chr) FmtPercent(num float64, v uint64) string {
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(chr.decimal)
 	b := make([]byte, 0, l)
@@ -254,12 +254,11 @@ func (chr *chr) FmtPercent(num float64, v uint64) (results string) {
 
 	b = append(b, chr.percent...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'chr'
-func (chr *chr) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (chr *chr) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := chr.currencies[currency]
@@ -312,13 +311,12 @@ func (chr *chr) FmtCurrency(num float64, v uint64, currency currency.Type) (resu
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'chr'
 // in accounting notation.
-func (chr *chr) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (chr *chr) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := chr.currencies[currency]
@@ -383,8 +381,7 @@ func (chr *chr) FmtAccounting(num float64, v uint64, currency currency.Type) (re
 		b = append(b, chr.currencyNegativeSuffix...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'chr'

chr_US/chr_US.go

@@ -69,7 +69,7 @@ func New() locales.Translator {
 		erasAbbreviated:        []string{"ᎤᏓᎷᎸ", "ᎤᎶᏐᏅ"},
 		erasNarrow:             []string{"", ""},
 		erasWide:               []string{"Ꮟ ᏥᏌ ᎾᏕᎲᏍᎬᎾ", "ᎠᎩᏃᎮᎵᏓᏍᏗᏱ ᎠᏕᏘᏱᏍᎬ ᏱᎰᏩ ᏧᏓᏂᎸᎢᏍᏗ"},
-		timezones:              map[string]string{"WAT": "WAT", "CST": "ᎠᏰᎵ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "WEZ": "WEZ", "WIB": "WIB", "OESZ": "OESZ", "LHST": "LHST", "ChST": "ChST", "HKST": "HKST", "CLT": "CLT", "OEZ": "OEZ", "SAST": "SAST", "NZDT": "NZDT", "PDT": "ᏭᏕᎵᎬ ᎢᎦ ᎢᏳᏩᎪᏗ", "ACST": "ACST", "WAST": "WAST", "JST": "JST", "∅∅∅": "∅∅∅", "AKDT": "AKDT", "EAT": "EAT", "GFT": "GFT", "ACWST": "ACWST", "ACWDT": "ACWDT", "UYT": "UYT", "UYST": "UYST", "GYT": "GYT", "BT": "BT", "AWST": "AWST", "CLST": "CLST", "ADT": "ADT", "VET": "VET", "COT": "COT", "MEZ": "MEZ", "AWDT": "AWDT", "HKT": "HKT", "GMT": "ᎢᏤ ᎢᏳᏍᏗ ᎢᏳᏩᎪᏗ", "BOT": "BOT", "SRT": "SRT", "WITA": "WITA", "CAT": "CAT", "EDT": "ᎧᎸᎬᎢᏗᏢ ᎢᎦ ᎢᏳᏩᎪᏗ", "WARST": "WARST", "AST": "AST", "WIT": "WIT", "COST": "COST", "ARST": "ARST", "CDT": "ᎠᏰᎵ ᎢᎦ ᎢᏳᏩᎪᏗ", "MST": "MST", "PST": "ᏭᏕᎵᎬ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "TMT": "TMT", "CHAST": "CHAST", "TMST": "TMST", "ACDT": "ACDT", "ART": "ART", "MESZ": "MESZ", "AKST": "AKST", "HADT": "HADT", "HNT": "HNT", "HAT": "HAT", "EST": "ᎧᎸᎬᎢᏗᏢ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "AEST": "AEST", "AEDT": "AEDT", "JDT": "JDT", "MYT": "MYT", "IST": "IST", "WESZ": "WESZ", "LHDT": "LHDT", "HAST": "HAST", "WART": "WART", "NZST": "NZST", "CHADT": "CHADT", "ECT": "ECT", "SGT": "SGT", "MDT": "MDT"},
+		timezones:              map[string]string{"COT": "COT", "JDT": "JDT", "OESZ": "OESZ", "PST": "ᏭᏕᎵᎬ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "ARST": "ARST", "CDT": "ᎠᏰᎵ ᎢᎦ ᎢᏳᏩᎪᏗ", "MESZ": "MESZ", "OEZ": "OEZ", "AEDT": "AEDT", "HAT": "HAT", "LHST": "LHST", "CLST": "CLST", "VET": "VET", "BOT": "BOT", "ACWST": "ACWST", "AEST": "AEST", "ACDT": "ACDT", "HKST": "HKST", "AWST": "AWST", "∅∅∅": "∅∅∅", "SAST": "SAST", "AST": "AST", "ACST": "ACST", "UYST": "UYST", "AKST": "AKST", "COST": "COST", "NZST": "NZST", "EST": "ᎧᎸᎬᎢᏗᏢ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "AKDT": "AKDT", "EAT": "EAT", "GMT": "ᎢᏤ ᎢᏳᏍᏗ ᎢᏳᏩᎪᏗ", "ChST": "ChST", "HADT": "HADT", "WAT": "WAT", "WEZ": "WEZ", "WESZ": "WESZ", "HAST": "HAST", "MST": "MST", "MDT": "MDT", "UYT": "UYT", "TMT": "TMT", "HKT": "HKT", "CHADT": "CHADT", "WIB": "WIB", "SGT": "SGT", "PDT": "ᏭᏕᎵᎬ ᎢᎦ ᎢᏳᏩᎪᏗ", "MYT": "MYT", "IST": "IST", "SRT": "SRT", "CAT": "CAT", "WAST": "WAST", "MEZ": "MEZ", "HNT": "HNT", "GYT": "GYT", "WITA": "WITA", "EDT": "ᎧᎸᎬᎢᏗᏢ ᎢᎦ ᎢᏳᏩᎪᏗ", "BT": "BT", "CHAST": "CHAST", "CLT": "CLT", "WART": "WART", "TMST": "TMST", "ACWDT": "ACWDT", "AWDT": "AWDT", "WIT": "WIT", "LHDT": "LHDT", "JST": "JST", "WARST": "WARST", "ADT": "ADT", "CST": "ᎠᏰᎵ ᏰᎵᏊ ᏗᏙᎳᎩ ᎢᏳᏩᎪᏗ", "ECT": "ECT", "NZDT": "NZDT", "GFT": "GFT", "ART": "ART"},
 	}
 }
 
@@ -186,7 +186,8 @@ func (chr *chr_US) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'chr_US' and handles both Whole and Real numbers based on 'v'
-func (chr *chr_US) FmtNumber(num float64, v uint64) (results string) {
+func (chr *chr_US) FmtNumber(num float64, v uint64) string {
+
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(chr.decimal) + len(chr.group)*len(s[:len(s)-int(v)-1])/3
 	count := 0
@@ -222,13 +223,12 @@ func (chr *chr_US) FmtNumber(num float64, v uint64) (results string) {
 		b[i], b[j] = b[j], b[i]
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'chr_US' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (chr *chr_US) FmtPercent(num float64, v uint64) (results string) {
+func (chr *chr_US) FmtPercent(num float64, v uint64) string {
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	l := len(s) + len(chr.decimal)
 	b := make([]byte, 0, l)
@@ -254,12 +254,11 @@ func (chr *chr_US) FmtPercent(num float64, v uint64) (results string) {
 
 	b = append(b, chr.percent...)
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'chr_US'
-func (chr *chr_US) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (chr *chr_US) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := chr.currencies[currency]
@@ -312,13 +311,12 @@ func (chr *chr_US) FmtCurrency(num float64, v uint64, currency currency.Type) (r
 		}
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'chr_US'
 // in accounting notation.
-func (chr *chr_US) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (chr *chr_US) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := chr.currencies[currency]
@@ -383,8 +381,7 @@ func (chr *chr_US) FmtAccounting(num float64, v uint64, currency currency.Type)
 		b = append(b, chr.currencyNegativeSuffix...)
 	}
 
-	results = string(b)
-	return
+	return string(b)
 }
 
 // FmtDateShort returns the short date representation of 't' for 'chr_US'

ckb/ckb.go

@@ -59,7 +59,7 @@ func New() locales.Translator {
 		erasAbbreviated:   []string{"پ.ن", "ز"},
 		erasNarrow:        []string{"پ.ن", "ز"},
 		erasWide:          []string{"پێش زایین", "زایینی"},
-		timezones:         map[string]string{"WITA": "WITA", "WESZ": "WESZ", "AWST": "AWST", "CLT": "CLT", "OESZ": "OESZ", "WAST": "WAST", "GYT": "GYT", "SRT": "SRT", "TMT": "TMT", "MYT": "MYT", "GMT": "GMT", "AEST": "AEST", "CST": "CST", "HNT": "HNT", "CAT": "CAT", "WART": "WART", "MESZ": "MESZ", "LHST": "LHST", "ECT": "ECT", "∅∅∅": "∅∅∅", "WEZ": "WEZ", "CHADT": "CHADT", "COT": "COT", "EST": "EST", "PDT": "PDT", "ADT": "ADT", "ACST": "ACST", "OEZ": "OEZ", "CHAST": "CHAST", "VET": "VET", "MDT": "MDT", "MEZ": "MEZ", "ART": "ART", "LHDT": "LHDT", "ChST": "ChST", "CDT": "CDT", "WARST": "WARST", "TMST": "TMST", "MST": "MST", "PST": "PST", "BT": "BT", "ACWST": "ACWST", "WIT": "WIT", "JST": "JST", "EAT": "EAT", "EDT": "EDT", "NZDT": "NZDT", "WAT": "WAT", "GFT": "GFT", "JDT": "JDT", "SGT": "SGT", "CLST": "CLST", "AEDT": "AEDT", "AST": "AST", "SAST": "SAST", "HAST": "HAST", "AWDT": "AWDT", "UYT": "UYT", "NZST": "NZST", "ACDT": "ACDT", "ACWDT": "ACWDT", "IST": "IST", "HAT": "HAT", "HKST": "HKST", "WIB": "WIB", "BOT": "BOT", "ARST": "ARST", "AKST": "AKST", "AKDT": "AKDT", "HADT": "HADT", "HKT": "HKT", "UYST": "UYST", "COST": "COST"},
+		timezones:         map[string]string{"AEST": "AEST", "ACST": "ACST", "PDT": "PDT", "CAT": "CAT", "COST": "COST", "MDT": "MDT", "LHST": "LHST", "LHDT": "LHDT", "TMT": "TMT", "BT": "BT", "CST": "CST", "CDT": "CDT", "WAT": "WAT", "WESZ": "WESZ", "ACWDT": "ACWDT", "COT": "COT", "WIB": "WIB", "AWST": "AWST", "SRT": "SRT", "HAT": "HAT", "GYT": "GYT", "HNT": "HNT", "AKDT": "AKDT", "WAST": "WAST", "JDT": "JDT", "ACDT": "ACDT", "ECT": "ECT", "ACWST": "ACWST", "AST": "AST", "CLST": "CLST", "UYST": "UYST", "PST": "PST", "GFT": "GFT", "TMST": "TMST", "AKST": "AKST", "CLT": "CLT", "AWDT": "AWDT", "IST": "IST", "WITA": "WITA", "ART": "ART", "EAT": "EAT", "OEZ": "OEZ", "AEDT": "AEDT", "MYT": "MYT", "WARST": "WARST", "ARST": "ARST", "HADT": "HADT", "CHADT": "CHADT", "JST": "JST", "MEZ": "MEZ", "WIT": "WIT", "CHAST": "CHAST", "WART": "WART", "HKT": "HKT", "HKST": "HKST", "∅∅∅": "∅∅∅", "WEZ": "WEZ", "NZST": "NZST", "SAST": "SAST", "ChST": "ChST", "EST": "EST", "MST": "MST", "NZDT": "NZDT", "BOT": "BOT", "ADT": "ADT", "SGT": "SGT", "UYT": "UYT", "GMT": "GMT", "EDT": "EDT", "MESZ": "MESZ", "OESZ": "OESZ", "VET": "VET", "HAST": "HAST"},
 	}
 }
 
@@ -176,35 +176,32 @@ func (ckb *ckb) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'ckb' and handles both Whole and Real numbers based on 'v'
-func (ckb *ckb) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ckb *ckb) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'ckb' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (ckb *ckb) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ckb *ckb) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'ckb'
-func (ckb *ckb) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (ckb *ckb) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ckb.currencies[currency]
-	results = string(append(append([]byte{}, symbol...), s...))
-	return
+	return string(append(append([]byte{}, symbol...), s...))
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'ckb'
 // in accounting notation.
-func (ckb *ckb) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (ckb *ckb) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ckb.currencies[currency]
-	results = string(append(append([]byte{}, symbol...), s...))
-	return
+	return string(append(append([]byte{}, symbol...), s...))
 }
 
 // FmtDateShort returns the short date representation of 't' for 'ckb'

ckb_IQ/ckb_IQ.go

@@ -59,7 +59,7 @@ func New() locales.Translator {
 		erasAbbreviated:   []string{"پ.ن", "ز"},
 		erasNarrow:        []string{"پ.ن", "ز"},
 		erasWide:          []string{"پێش زایین", "زایینی"},
-		timezones:         map[string]string{"ACWST": "ACWST", "HADT": "HADT", "EAT": "EAT", "UYT": "UYT", "WAST": "WAST", "ADT": "ADT", "ACWDT": "ACWDT", "ECT": "ECT", "BOT": "BOT", "GYT": "GYT", "WART": "WART", "AEST": "AEST", "BT": "BT", "TMT": "TMT", "JDT": "JDT", "EST": "EST", "PDT": "PDT", "ACDT": "ACDT", "WARST": "WARST", "MST": "MST", "HAST": "HAST", "AWDT": "AWDT", "HNT": "HNT", "GMT": "GMT", "CHAST": "CHAST", "SAST": "SAST", "LHDT": "LHDT", "JST": "JST", "∅∅∅": "∅∅∅", "HKST": "HKST", "COT": "COT", "MEZ": "MEZ", "MESZ": "MESZ", "GFT": "GFT", "LHST": "LHST", "WESZ": "WESZ", "ARST": "ARST", "CDT": "CDT", "HKT": "HKT", "TMST": "TMST", "MYT": "MYT", "AKST": "AKST", "AKDT": "AKDT", "EDT": "EDT", "NZDT": "NZDT", "ART": "ART", "SRT": "SRT", "MDT": "MDT", "CLST": "CLST", "UYST": "UYST", "VET": "VET", "WAT": "WAT", "AST": "AST", "CST": "CST", "HAT": "HAT", "OESZ": "OESZ", "WIB": "WIB", "COST": "COST", "WIT": "WIT", "CLT": "CLT", "OEZ": "OEZ", "WITA": "WITA", "PST": "PST", "CHADT": "CHADT", "ACST": "ACST", "AWST": "AWST", "CAT": "CAT", "AEDT": "AEDT", "ChST": "ChST", "IST": "IST", "SGT": "SGT", "WEZ": "WEZ", "NZST": "NZST"},
+		timezones:         map[string]string{"AWDT": "AWDT", "ARST": "ARST", "CDT": "CDT", "COST": "COST", "MST": "MST", "MDT": "MDT", "IST": "IST", "PST": "PST", "CLST": "CLST", "∅∅∅": "∅∅∅", "UYST": "UYST", "BT": "BT", "CHAST": "CHAST", "TMT": "TMT", "HAST": "HAST", "HADT": "HADT", "LHST": "LHST", "AWST": "AWST", "HKST": "HKST", "ChST": "ChST", "WIT": "WIT", "CST": "CST", "ECT": "ECT", "WESZ": "WESZ", "ACWDT": "ACWDT", "WAT": "WAT", "CLT": "CLT", "OEZ": "OEZ", "MYT": "MYT", "SGT": "SGT", "ART": "ART", "HKT": "HKT", "UYT": "UYT", "EDT": "EDT", "NZST": "NZST", "NZDT": "NZDT", "PDT": "PDT", "HAT": "HAT", "OESZ": "OESZ", "GYT": "GYT", "CAT": "CAT", "GMT": "GMT", "MEZ": "MEZ", "JDT": "JDT", "AEST": "AEST", "WARST": "WARST", "AKDT": "AKDT", "SAST": "SAST", "JST": "JST", "VET": "VET", "GFT": "GFT", "BOT": "BOT", "AKST": "AKST", "CHADT": "CHADT", "WIB": "WIB", "ADT": "ADT", "HNT": "HNT", "ACWST": "ACWST", "AST": "AST", "SRT": "SRT", "EAT": "EAT", "ACST": "ACST", "MESZ": "MESZ", "TMST": "TMST", "WITA": "WITA", "EST": "EST", "COT": "COT", "WEZ": "WEZ", "WAST": "WAST", "ACDT": "ACDT", "AEDT": "AEDT", "LHDT": "LHDT", "WART": "WART"},
 	}
 }
 
@@ -176,35 +176,32 @@ func (ckb *ckb_IQ) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'ckb_IQ' and handles both Whole and Real numbers based on 'v'
-func (ckb *ckb_IQ) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ckb *ckb_IQ) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'ckb_IQ' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (ckb *ckb_IQ) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ckb *ckb_IQ) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'ckb_IQ'
-func (ckb *ckb_IQ) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (ckb *ckb_IQ) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ckb.currencies[currency]
-	results = string(append(append([]byte{}, symbol...), s...))
-	return
+	return string(append(append([]byte{}, symbol...), s...))
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'ckb_IQ'
 // in accounting notation.
-func (ckb *ckb_IQ) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (ckb *ckb_IQ) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ckb.currencies[currency]
-	results = string(append(append([]byte{}, symbol...), s...))
-	return
+	return string(append(append([]byte{}, symbol...), s...))
 }
 
 // FmtDateShort returns the short date representation of 't' for 'ckb_IQ'

ckb_IR/ckb_IR.go

@@ -59,7 +59,7 @@ func New() locales.Translator {
 		erasAbbreviated:   []string{"پ.ن", "ز"},
 		erasNarrow:        []string{"پ.ن", "ز"},
 		erasWide:          []string{"پێش زایین", "زایینی"},
-		timezones:         map[string]string{"EST": "EST", "COST": "COST", "ART": "ART", "SGT": "SGT", "AWST": "AWST", "∅∅∅": "∅∅∅", "WEZ": "WEZ", "HAT": "HAT", "JDT": "JDT", "BT": "BT", "AST": "AST", "GFT": "GFT", "WITA": "WITA", "PDT": "PDT", "GYT": "GYT", "WARST": "WARST", "VET": "VET", "EAT": "EAT", "CHAST": "CHAST", "MEZ": "MEZ", "SAST": "SAST", "HNT": "HNT", "SRT": "SRT", "WESZ": "WESZ", "AEDT": "AEDT", "AKDT": "AKDT", "CST": "CST", "PST": "PST", "ACDT": "ACDT", "TMT": "TMT", "TMST": "TMST", "WIB": "WIB", "HKST": "HKST", "AEST": "AEST", "OEZ": "OEZ", "BOT": "BOT", "ACST": "ACST", "MST": "MST", "HKT": "HKT", "CDT": "CDT", "NZST": "NZST", "WAT": "WAT", "ACWST": "ACWST", "LHDT": "LHDT", "NZDT": "NZDT", "CHADT": "CHADT", "CAT": "CAT", "EDT": "EDT", "CLT": "CLT", "WIT": "WIT", "IST": "IST", "HADT": "HADT", "UYT": "UYT", "WAST": "WAST", "MESZ": "MESZ", "MDT": "MDT", "MYT": "MYT", "WART": "WART", "ADT": "ADT", "ACWDT": "ACWDT", "ChST": "ChST", "AWDT": "AWDT", "UYST": "UYST", "OESZ": "OESZ", "ARST": "ARST", "ECT": "ECT", "AKST": "AKST", "CLST": "CLST", "GMT": "GMT", "COT": "COT", "JST": "JST", "LHST": "LHST", "HAST": "HAST"},
+		timezones:         map[string]string{"MDT": "MDT", "CAT": "CAT", "TMT": "TMT", "COT": "COT", "JDT": "JDT", "AWDT": "AWDT", "AKDT": "AKDT", "COST": "COST", "CHAST": "CHAST", "GFT": "GFT", "HAT": "HAT", "WITA": "WITA", "AKST": "AKST", "ACWDT": "ACWDT", "AEST": "AEST", "SGT": "SGT", "CST": "CST", "HNT": "HNT", "ARST": "ARST", "HAST": "HAST", "AWST": "AWST", "GMT": "GMT", "ChST": "ChST", "NZDT": "NZDT", "CLT": "CLT", "ACDT": "ACDT", "HKT": "HKT", "HADT": "HADT", "ECT": "ECT", "AEDT": "AEDT", "CDT": "CDT", "PST": "PST", "MYT": "MYT", "WEZ": "WEZ", "ACWST": "ACWST", "WART": "WART", "IST": "IST", "ADT": "ADT", "HKST": "HKST", "EST": "EST", "LHST": "LHST", "MESZ": "MESZ", "OEZ": "OEZ", "ACST": "ACST", "GYT": "GYT", "WIT": "WIT", "BT": "BT", "TMST": "TMST", "CHADT": "CHADT", "MEZ": "MEZ", "JST": "JST", "PDT": "PDT", "UYST": "UYST", "EAT": "EAT", "WIB": "WIB", "CLST": "CLST", "VET": "VET", "∅∅∅": "∅∅∅", "ART": "ART", "SAST": "SAST", "MST": "MST", "OESZ": "OESZ", "SRT": "SRT", "UYT": "UYT", "EDT": "EDT", "NZST": "NZST", "WAST": "WAST", "WESZ": "WESZ", "LHDT": "LHDT", "AST": "AST", "BOT": "BOT", "WARST": "WARST", "WAT": "WAT"},
 	}
 }
 
@@ -176,35 +176,32 @@ func (ckb *ckb_IR) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for 'ckb_IR' and handles both Whole and Real numbers based on 'v'
-func (ckb *ckb_IR) FmtNumber(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ckb *ckb_IR) FmtNumber(num float64, v uint64) string {
+
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for 'ckb_IR' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func (ckb *ckb_IR) FmtPercent(num float64, v uint64) (results string) {
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+func (ckb *ckb_IR) FmtPercent(num float64, v uint64) string {
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'ckb_IR'
-func (ckb *ckb_IR) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func (ckb *ckb_IR) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ckb.currencies[currency]
-	results = string(append(append([]byte{}, symbol...), s...))
-	return
+	return string(append(append([]byte{}, symbol...), s...))
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'ckb_IR'
 // in accounting notation.
-func (ckb *ckb_IR) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func (ckb *ckb_IR) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := ckb.currencies[currency]
-	results = string(append(append([]byte{}, symbol...), s...))
-	return
+	return string(append(append([]byte{}, symbol...), s...))
 }
 
 // FmtDateShort returns the short date representation of 't' for 'ckb_IR'

cmd/generate_resources.go

@@ -22,6 +22,11 @@ const (
 )
 
 var (
+	tfuncs = template.FuncMap{
+		"is_multibyte": func(s string) bool {
+			return len([]byte(s)) > 1
+		},
+	}
 	prVarFuncs = map[string]string{
 		"n": "n := math.Abs(num)\n",
 		"i": "i := int64(n)\n",
@@ -155,7 +160,7 @@ func main() {
 	var err error
 
 	// load template
-	tmpl, err = template.ParseGlob("*.tmpl")
+	tmpl, err = template.New("all").Funcs(tfuncs).ParseGlob("*.tmpl")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -251,37 +256,6 @@ func main() {
 			log.Panic(err)
 		}
 	}
-
-	fmt.Println("Writing final locale map")
-
-	if err = os.MkdirAll(fmt.Sprintf(locDir, "locales-list"), 0777); err != nil {
-		log.Fatal(err)
-	}
-
-	filename = fmt.Sprintf(locFilename, "locales-list", "locales")
-
-	output, err = os.Create(filename)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer output.Close()
-
-	if err := tmpl.ExecuteTemplate(output, "localeslist", locMap); err != nil {
-		log.Fatal(err)
-	}
-
-	output.Close()
-
-	// after file written run gofmt on file to ensure best formatting
-	cmd = exec.Command("goimports", "-w", filename)
-	if err = cmd.Run(); err != nil {
-		log.Panic(err)
-	}
-
-	cmd = exec.Command("gofmt", "-s", "-w", filename)
-	if err = cmd.Run(); err != nil {
-		log.Panic(err)
-	}
 }
 
 func postProcess(cldr *cldr.CLDR) {
@@ -1757,13 +1731,13 @@ func parsePercentNumberFormat(trans *translator) {
 		}
 	}
 
-	if len(trans.FmtPercentPrefix) > 0 {
-		trans.FmtPercentPrefix = fmt.Sprintf("%#v", []byte(trans.FmtPercentPrefix))
-	}
+	// if len(trans.FmtPercentPrefix) > 0 {
+	// 	trans.FmtPercentPrefix = fmt.Sprintf("%#v", []byte(trans.FmtPercentPrefix))
+	// }
 
-	if len(trans.FmtPercentSuffix) > 0 {
-		trans.FmtPercentSuffix = fmt.Sprintf("%#v", []byte(trans.FmtPercentSuffix))
-	}
+	// if len(trans.FmtPercentSuffix) > 0 {
+	// 	trans.FmtPercentSuffix = fmt.Sprintf("%#v", []byte(trans.FmtPercentSuffix))
+	// }
 
 	return
 }

cmd/translator.tmpl

@@ -20,10 +20,10 @@ type {{ .Locale }} struct {
 	minus      			   string
 	percent    			   string
 	{{- if gt (len .FmtPercentPrefix) 0}}
-	percentPrefix   	   []byte
+	percentPrefix   	   string
 	{{- end }}
 	{{- if gt (len .FmtPercentSuffix) 0}}
-	percentSuffix   	   []byte
+	percentSuffix   	   string
 	{{- end }}
 	perMille   			   string
 	timeSeparator		   string
@@ -88,10 +88,10 @@ func New() locales.Translator {
 		{{- end}}
 		currencies:      {{ .Currencies }},
 		{{- if gt (len .FmtPercentPrefix) 0}}
-		percentPrefix:   {{ .FmtPercentPrefix }},
+		percentPrefix:   "{{ .FmtPercentPrefix }}",
 		{{- end -}}
 		{{- if gt (len .FmtPercentSuffix) 0}}
-		percentSuffix:   {{ .FmtPercentSuffix }},
+		percentSuffix:   "{{ .FmtPercentSuffix }}",
 		{{- end -}}
 		{{- if gt (len .FmtCurrencyPrefix) 0}}
 		currencyPositivePrefix:   "{{ .FmtCurrencyPrefix }}",
@@ -257,9 +257,9 @@ func({{ .BaseLocale }} *{{ .Locale }}) WeekdaysWide() []string {
 }
 
 // FmtNumber returns 'num' with digits/precision of 'v' for '{{ .Locale }}' and handles both Whole and Real numbers based on 'v'
-func({{ .BaseLocale }} *{{ .Locale }}) FmtNumber(num float64, v uint64) (results string) {
+func({{ .BaseLocale }} *{{ .Locale }}) FmtNumber(num float64, v uint64) string {
 
-	{{- if eq .FmtNumberExists true }}
+	{{ if eq .FmtNumberExists true }}
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	{{- if gt .FmtNumberGroupLen 0 }}
 	l := len(s) + len({{ .BaseLocale }}.decimal) + len({{ .BaseLocale }}.group) * len(s[:len(s)-int(v)-1]) / {{ .FmtNumberGroupLen }}
@@ -278,13 +278,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtNumber(num float64, v uint64) (results
 
 		if s[i] == '.' {
 
-			{{- if eq (len .Decimal) 1 }}
-			b = append(b, {{ .BaseLocale }}.decimal[0])
-			{{- else }}
+			{{- if is_multibyte .Decimal }}
 			for j := len({{ .BaseLocale }}.decimal) - 1; j >= 0; j-- {
 				b = append(b, {{ .BaseLocale }}.decimal[j])
 			}
-			{{ end -}}
+			{{- else }}
+			b = append(b, {{ .BaseLocale }}.decimal[0])
+			{{- end -}}
 			{{- if gt .FmtNumberGroupLen 0 }}
 			inWhole = true
 			{{- end }}
@@ -297,13 +297,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtNumber(num float64, v uint64) (results
 			{{- if gt .FmtNumberSecondaryGroupLen 0}}
 			
 			if count == groupThreshold {
-				{{- if eq (len .Group) 1 }}
-				b = append(b, {{ .BaseLocale }}.group[0])
-				{{- else }}
+				{{- if is_multibyte .Group }}
 				for j := len({{ .BaseLocale }}.group) - 1; j >= 0; j-- {
 					b = append(b, {{ .BaseLocale }}.group[j])
 				}
-				{{ end }}
+				{{- else }}
+				b = append(b, {{ .BaseLocale }}.group[0])
+				{{- end }}
 				count = 1
 
 				if !inSecondary {
@@ -312,13 +312,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtNumber(num float64, v uint64) (results
 				}
 			{{ else }}
 			if count == {{ .FmtNumberGroupLen }} {
-				{{- if eq (len .Group) 1 }}
-				b = append(b, {{ .BaseLocale }}.group[0])
-				{{- else }}
+				{{- if is_multibyte .Group }}
 				for j := len({{ .BaseLocale }}.group) - 1; j >= 0; j-- {
 					b = append(b, {{ .BaseLocale }}.group[j])
 				}
-				{{ end }}
+				{{- else }}
+				b = append(b, {{ .BaseLocale }}.group[0])
+				{{- end }}
 				count = 1
 			{{ end -}}
 			} else {
@@ -332,12 +332,12 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtNumber(num float64, v uint64) (results
 	}
 
 	if num < 0 {
-		{{- if eq (len .Minus) 1 }}
-		b = append(b, {{ .BaseLocale }}.minus[0])
-		{{ else }}
+		{{- if is_multibyte .Minus }}
 		for j := len({{ .BaseLocale }}.minus) - 1; j >= 0; j-- {
 			b = append(b, {{ .BaseLocale }}.minus[j])
 		}
+		{{ else }}
+		b = append(b, {{ .BaseLocale }}.minus[0])
 		{{ end -}}
 	}
 
@@ -359,17 +359,15 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtNumber(num float64, v uint64) (results
 	}
 	{{ end }}
 
-	results = string(b)
-	return
+	return string(b)
 	{{ else }}
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	{{ end -}}
 }
 
 // FmtPercent returns 'num' with digits/precision of 'v' for '{{ .Locale }}' and handles both Whole and Real numbers based on 'v'
 // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
-func({{ .BaseLocale }} *{{ .Locale }}) FmtPercent(num float64, v uint64) (results string) {
+func({{ .BaseLocale }} *{{ .Locale }}) FmtPercent(num float64, v uint64) string {
 
 	{{- if eq .FmtPercentExists true }}
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
@@ -390,13 +388,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtPercent(num float64, v uint64) (result
 
 		if s[i] == '.' {
 
-			{{- if eq (len .Decimal) 1 }}
-			b = append(b, {{ .BaseLocale }}.decimal[0])
-			{{- else }}
+			{{- if is_multibyte .Decimal }}
 			for j := len({{ .BaseLocale }}.decimal) - 1; j >= 0; j-- {
 				b = append(b, {{ .BaseLocale }}.decimal[j])
 			}
-			{{ end -}}
+			{{- else }}
+			b = append(b, {{ .BaseLocale }}.decimal[0])
+			{{- end -}}
 			{{- if gt .FmtPercentGroupLen 0 }}
 			inWhole = true
 			{{ end }}
@@ -409,13 +407,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtPercent(num float64, v uint64) (result
 			{{- if gt .FmtPercentSecondaryGroupLen 0}}
 			
 			if count == groupThreshold {
-				{{- if eq (len .Group) 1 }}
-				b = append(b, {{ .BaseLocale }}.group[0])
-				{{- else }}
+				{{- if is_multibyte .Group }}
 				for j := len({{ .BaseLocale }}.group) - 1; j >= 0; j-- {
 					b = append(b, {{ .BaseLocale }}.group[j])
 				}
-				{{ end }}
+				{{- else }}
+				b = append(b, {{ .BaseLocale }}.group[0])
+				{{- end }}
 				count = 1
 
 				if !inSecondary {
@@ -424,13 +422,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtPercent(num float64, v uint64) (result
 				}
 			{{ else }}
 			if count == {{ .FmtPercentGroupLen }} {
-				{{- if eq (len .Group) 1 }}
-				b = append(b, {{ .BaseLocale }}.group[0])
-				{{- else }}
+				{{- if is_multibyte .Group }}
 				for j := len({{ .BaseLocale }}.group) - 1; j >= 0; j-- {
 					b = append(b, {{ .BaseLocale }}.group[j])
 				}
-				{{ end }}
+				{{- else }}
+				b = append(b, {{ .BaseLocale }}.group[0])
+				{{- end }}
 				count = 1
 			{{ end -}}
 			} else {
@@ -444,22 +442,22 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtPercent(num float64, v uint64) (result
 	}
 
 	if num < 0 {
-		{{- if eq (len .Minus) 1 }}
-		b = append(b, {{ .BaseLocale }}.minus[0])
-		{{ else }}
+		{{- if is_multibyte .Minus }}
 		for j := len({{ .BaseLocale }}.minus) - 1; j >= 0; j-- {
 			b = append(b, {{ .BaseLocale }}.minus[j])
 		}
+		{{ else }}
+		b = append(b, {{ .BaseLocale }}.minus[0])
 		{{ end -}}
 	}
 
 	{{ if and .FmtPercentInPrefix (not .FmtPercentLeft) }}
-		{{- if eq (len .Percent) 1 }}
-		b = append(b, {{ .BaseLocale }}.percent[0])
-		{{ else }}
+		{{- if is_multibyte .Percent }}
 		for j := len({{ .BaseLocale }}.percent) - 1; j >= 0; j-- {
 			b = append(b, {{ .BaseLocale }}.percent[j])
 		}
+		{{ else }}
+		b = append(b, {{ .BaseLocale }}.percent[0])
 		{{ end }}
 	{{ end }}
 
@@ -474,12 +472,12 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtPercent(num float64, v uint64) (result
 	{{ end }}
 
 	{{ if and .FmtPercentInPrefix .FmtPercentLeft }}
-		{{- if eq (len .Percent) 1 }}
-		b = append(b, {{ .BaseLocale }}.percent[0])
-		{{ else }}
+		{{- if is_multibyte .Percent }}
 		for j := len({{ .BaseLocale }}.percent) - 1; j >= 0; j-- {
 			b = append(b, {{ .BaseLocale }}.percent[j])
 		}
+		{{ else }}
+		b = append(b, {{ .BaseLocale }}.percent[0])
 		{{ end }}
 	{{ end }}
 
@@ -513,16 +511,14 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtPercent(num float64, v uint64) (result
 		b = append(b, {{ .BaseLocale }}.percent...)
 	{{ end }}
 
-	results = string(b)
-	return
+	return string(b)
 	{{ else }}
-	results = strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
-	return
+	return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	{{ end -}}
 }
 
 // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for '{{ .Locale }}'
-func({{ .BaseLocale }} *{{ .Locale }}) FmtCurrency(num float64, v uint64, currency currency.Type) (results string) {
+func({{ .BaseLocale }} *{{ .Locale }}) FmtCurrency(num float64, v uint64, currency currency.Type) string {
 	
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := {{ .BaseLocale }}.currencies[currency]
@@ -544,13 +540,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtCurrency(num float64, v uint64, curren
 
 		if s[i] == '.' {
 
-			{{- if eq (len .Decimal) 1 }}
-			b = append(b, {{ .BaseLocale }}.decimal[0])
-			{{- else }}
+			{{- if is_multibyte .Decimal }}
 			for j := len({{ .BaseLocale }}.decimal) - 1; j >= 0; j-- {
 				b = append(b, {{ .BaseLocale }}.decimal[j])
 			}
-			{{ end -}}
+			{{- else }}
+			b = append(b, {{ .BaseLocale }}.decimal[0])
+			{{- end -}}
 			{{- if gt .FmtCurrencyGroupLen 0 }}
 			inWhole = true
 			{{- end }}
@@ -563,13 +559,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtCurrency(num float64, v uint64, curren
 			{{- if gt .FmtCurrencySecondaryGroupLen 0}}
 			
 			if count == groupThreshold {
-				{{- if eq (len .Group) 1 }}
-				b = append(b, {{ .BaseLocale }}.group[0])
-				{{- else }}
+				{{- if is_multibyte .Group }}
 				for j := len({{ .BaseLocale }}.group) - 1; j >= 0; j-- {
 					b = append(b, {{ .BaseLocale }}.group[j])
 				}
-				{{ end }}
+				{{- else }}
+				b = append(b, {{ .BaseLocale }}.group[0])
+				{{- end }}
 				count = 1
 
 				if !inSecondary {
@@ -578,13 +574,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtCurrency(num float64, v uint64, curren
 				}
 			{{ else }}
 			if count == {{ .FmtCurrencyGroupLen }} {
-				{{- if eq (len .Group) 1 }}
-				b = append(b, {{ .BaseLocale }}.group[0])
-				{{- else }}
+				{{- if is_multibyte .Group }}
 				for j := len({{ .BaseLocale }}.group) - 1; j >= 0; j-- {
 					b = append(b, {{ .BaseLocale }}.group[j])
 				}
-				{{ end }}
+				{{- else }}
+				b = append(b, {{ .BaseLocale }}.group[0])
+				{{- end }}
 				count = 1
 			{{ end -}}
 			} else {
@@ -620,12 +616,12 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtCurrency(num float64, v uint64, curren
 	{{ end }}
 
 	if num < 0 {
-		{{- if eq (len .Minus) 1 }}
-		b = append(b, {{ .BaseLocale }}.minus[0])
-		{{ else }}
+		{{- if is_multibyte .Minus }}
 		for j := len({{ .BaseLocale }}.minus) - 1; j >= 0; j-- {
 			b = append(b, {{ .BaseLocale }}.minus[j])
 		}
+		{{ else -}}
+		b = append(b, {{ .BaseLocale }}.minus[0])
 		{{ end -}}
 	}
 
@@ -659,17 +655,15 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtCurrency(num float64, v uint64, curren
 		b = append(b, symbol...)
 	{{ end }}
 
-	results = string(b)
-	return
+	return string(b)
 	{{ else }}
-	results = string(append(append([]byte{}, symbol...), s...))
-	return
+	return string(append(append([]byte{}, symbol...), s...))
 	{{ end -}}
 }
 
 // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for '{{ .Locale }}'
 // in accounting notation.
-func({{ .BaseLocale }} *{{ .Locale }}) FmtAccounting(num float64, v uint64, currency currency.Type) (results string) {
+func({{ .BaseLocale }} *{{ .Locale }}) FmtAccounting(num float64, v uint64, currency currency.Type) string {
 	
 	s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
 	symbol := {{ .BaseLocale }}.currencies[currency]
@@ -691,13 +685,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtAccounting(num float64, v uint64, curr
 
 		if s[i] == '.' {
 
-			{{- if eq (len .Decimal) 1 }}
-			b = append(b, {{ .BaseLocale }}.decimal[0])
-			{{- else }}
+			{{- if is_multibyte .Decimal }}
 			for j := len({{ .BaseLocale }}.decimal) - 1; j >= 0; j-- {
 				b = append(b, {{ .BaseLocale }}.decimal[j])
 			}
-			{{ end -}}
+			{{- else }}
+			b = append(b, {{ .BaseLocale }}.decimal[0])
+			{{- end -}}
 			{{- if gt .FmtCurrencyGroupLen 0 }}
 			inWhole = true
 			{{- end }}
@@ -710,13 +704,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtAccounting(num float64, v uint64, curr
 			{{- if gt .FmtCurrencySecondaryGroupLen 0}}
 			
 			if count == groupThreshold {
-				{{- if eq (len .Group) 1 }}
-				b = append(b, {{ .BaseLocale }}.group[0])
-				{{- else }}
+				{{- if is_multibyte .Group }}
 				for j := len({{ .BaseLocale }}.group) - 1; j >= 0; j-- {
 					b = append(b, {{ .BaseLocale }}.group[j])
 				}
-				{{ end }}
+				{{- else }}
+				b = append(b, {{ .BaseLocale }}.group[0])
+				{{- end }}
 				count = 1
 
 				if !inSecondary {
@@ -725,13 +719,13 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtAccounting(num float64, v uint64, curr
 				}
 			{{ else }}
 			if count == {{ .FmtCurrencyGroupLen }} {
-				{{- if eq (len .Group) 1 }}
-				b = append(b, {{ .BaseLocale }}.group[0])
-				{{- else }}
+				{{- if is_multibyte .Group }}
 				for j := len({{ .BaseLocale }}.group) - 1; j >= 0; j-- {
 					b = append(b, {{ .BaseLocale }}.group[j])
 				}
-				{{ end }}
+				{{- else }}
+				b = append(b, {{ .BaseLocale }}.group[0])
+				{{- end }}
 				count = 1
 			{{ end -}}
 			} else {
@@ -769,12 +763,12 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtAccounting(num float64, v uint64, curr
 		{{ end }}
 
 		{{ if eq (not .FmtCurrencyNegativeExists) true}}
-			{{- if eq (len .Minus) 1 }}
-			b = append(b, {{ .BaseLocale }}.minus[0])
-			{{ else }}
+			{{- if is_multibyte .Minus }}
 			for j := len({{ .BaseLocale }}.minus) - 1; j >= 0; j-- {
 				b = append(b, {{ .BaseLocale }}.minus[j])
 			}
+			{{ else -}}
+			b = append(b, {{ .BaseLocale }}.minus[0])
 			{{ end -}}
 		{{ end }}
 
@@ -855,11 +849,9 @@ func({{ .BaseLocale }} *{{ .Locale }}) FmtAccounting(num float64, v uint64, curr
 	}
 	{{- end }}
 
-	results = string(b)
-	return
+	return string(b)
 	{{ else }}
-	results = string(append(append([]byte{}, symbol...), s...))
-	return
+	return string(append(append([]byte{}, symbol...), s...))
 	{{ end -}}
 }