\n")
+ for _, obj := range idx.Objects {
+ if filterType != "" {
+ if strings.HasPrefix(filterType, "depth-") {
+ var d int
+ fmt.Sscanf(filterType, "depth-%d", &d)
+ if obj.Depth != d {
+ continue
+ }
+ } else if obj.ResolvedType != filterType && obj.Type != filterType {
+ continue
+ }
+ }
+ href := fmt.Sprintf("/pack/%s/%s?key=%s", url.PathEscape(repo), obj.Hash, key)
+ hashLink := fmt.Sprintf("%s", href, obj.Hash)
+
+ if obj.Depth > 0 {
+ baseHref := fmt.Sprintf("/pack/%s/%s?key=%s", url.PathEscape(repo), obj.BaseHash, key)
+ baseLink := fmt.Sprintf("%s", baseHref, obj.BaseHash)
+ fmt.Fprintf(w, "%s %-6s %d %d %d %d %s\n", hashLink, obj.ResolvedType, obj.Size, obj.EncodedSize, obj.Offset, obj.Depth, baseLink)
+ } else {
+ fmt.Fprintf(w, "%s %-6s %d %d %d\n", hashLink, obj.ResolvedType, obj.Size, obj.EncodedSize, obj.Offset)
+ }
+ }
+
+ // Summary.
+ fmt.Fprintf(w, "non delta: %d objects\n", nonDelta)
+ maxDepth := 0
+ for d := range chainLengths {
+ if d > maxDepth {
+ maxDepth = d
+ }
+ }
+ for d := 1; d <= maxDepth; d++ {
+ if c, ok := chainLengths[d]; ok {
+ href := fmt.Sprintf("/?pack=%s&type=depth-%d", url.QueryEscape(repoURL), d)
+ fmt.Fprintf(w, "chain length = %d: %d objects\n", d, href, c)
+ }
+ }
+
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintf(w, footer)
+ return nil
+}
+
+func (h *handler) renderPackObject(w http.ResponseWriter, r *http.Request) error {
+ ctx := r.Context()
+
+ // Path: /pack/\n")
+ if obj.Type != objType {
+ fmt.Fprintf(w, "type: %s (resolves to %s)\n", obj.Type, objType)
+ } else {
+ fmt.Fprintf(w, "type: %s\n", objType)
+ }
+ fmt.Fprintf(w, "size: %s (%d bytes)\n", formatBytes(int64(obj.Size)), obj.Size)
+ fmt.Fprintf(w, "offset: %d\n", obj.Offset)
+ fmt.Fprintf(w, "encoded: %d bytes\n", obj.EncodedSize)
+ if obj.BaseHash != "" {
+ baseHref := fmt.Sprintf("/pack/%s/%s?key=%s", url.PathEscape(repo), obj.BaseHash, key)
+ fmt.Fprintf(w, "base: %s (%s", baseHref, obj.BaseHash, obj.Type)
+ if obj.Type == "ofs-delta" {
+ fmt.Fprintf(w, ", offset %d", obj.BaseOffset)
+ }
+ fmt.Fprintf(w, ")\n")
+ fmt.Fprintf(w, "depth: %d\n", obj.Depth)
+ }
+ fmt.Fprintf(w, "\n")
+
+ // For delta objects, show the raw delta instructions.
+ if obj.Type == "ref-delta" || obj.Type == "ofs-delta" {
+ rawDelta, err := RawDelta(data, obj.Offset)
+ if err == nil {
+ deltaInfo, err := ParseDelta(rawDelta)
+ if err == nil {
+ h.renderDeltaOps(w, deltaInfo, repo, key, idx)
+ fmt.Fprintf(w, "\n")
+ }
+ }
+ fmt.Fprintf(w, "--- resolved content (%s) ---\n\n", objType)
+ }
+
+ // Render resolved content based on type.
+ switch objType {
+ case "commit":
+ h.renderPackCommit(w, content, repo, key)
+ case "tree":
+ h.renderPackTree(w, content, repo, key, idx)
+ case "blob":
+ size := min(int64(len(content)), tooBig)
+ esc := &dumbEscaper{buf: bufio.NewWriter(w)}
+ io.CopyN(esc, bytes.NewReader(content), size)
+ if int64(len(content)) > tooBig {
+ fmt.Fprintf(w, "\n... truncated (%s total)", formatBytes(int64(len(content))))
+ }
+ case "tag":
+ h.renderPackTag(w, content, repo, key)
+ default:
+ fmt.Fprintf(w, "(raw %d bytes)\n", len(content))
+ }
+
+ fmt.Fprintf(w, "\n")
+ fmt.Fprintf(w, footer)
+ return nil
+}
+
+func (h *handler) renderPackCommit(w io.Writer, content []byte, repo, key string) {
+ scanner := bufio.NewScanner(bytes.NewReader(content))
+ for scanner.Scan() {
+ line := scanner.Text()
+ hdr, val, ok := strings.Cut(line, " ")
+ if !ok {
+ fmt.Fprintf(w, "%s\n", htmlEscape(line))
+ continue
+ }
+ switch hdr {
+ case "tree", "parent":
+ href := fmt.Sprintf("/pack/%s/%s?key=%s", url.PathEscape(repo), val, key)
+ fmt.Fprintf(w, "%s %s\n", hdr, href, val)
+ default:
+ fmt.Fprintf(w, "%s\n", htmlEscape(line))
+ }
+ }
+}
+
+func (h *handler) renderPackTree(w io.Writer, content []byte, repo, key string, idx *PackIndex) {
+ // Build hash lookup.
+ hashSet := map[string]bool{}
+ for _, obj := range idx.Objects {
+ hashSet[obj.Hash] = true
+ }
+
+ data := content
+ for len(data) > 0 {
+ e, size := gitfs.ParseDirEntry(data)
+ if size == 0 {
+ break
+ }
+ data = data[size:]
+
+ hashStr := e.Hash.String()
+ typeStr := "blob"
+ if e.Mode == 0o40000 {
+ typeStr = "tree"
+ } else if e.Mode == 0o160000 {
+ typeStr = "commit"
+ }
+
+ name := htmlEscape(string(e.Name))
+ if hashSet[hashStr] {
+ href := fmt.Sprintf("/pack/%s/%s?key=%s", url.PathEscape(repo), hashStr, key)
+ fmt.Fprintf(w, "%06o %s %s\t%s\n", e.Mode, typeStr, href, hashStr, name)
+ } else {
+ fmt.Fprintf(w, "%06o %s %s\t%s\n", e.Mode, typeStr, hashStr, name)
+ }
+ }
+}
+
+func (h *handler) renderPackTag(w io.Writer, content []byte, repo, key string) {
+ scanner := bufio.NewScanner(bytes.NewReader(content))
+ for scanner.Scan() {
+ line := scanner.Text()
+ hdr, val, ok := strings.Cut(line, " ")
+ if !ok {
+ fmt.Fprintf(w, "%s\n", htmlEscape(line))
+ continue
+ }
+ switch hdr {
+ case "object":
+ href := fmt.Sprintf("/pack/%s/%s?key=%s", url.PathEscape(repo), val, key)
+ fmt.Fprintf(w, "%s %s\n", hdr, href, val)
+ default:
+ fmt.Fprintf(w, "%s\n", htmlEscape(line))
+ }
+ }
+}
+
+func (h *handler) renderDeltaOps(w io.Writer, info *DeltaInfo, repo, key string, idx *PackIndex) {
+ // Build hash lookup for linking.
+ hashSet := map[string]bool{}
+ for _, obj := range idx.Objects {
+ hashSet[obj.Hash] = true
+ }
+
+ fmt.Fprintf(w, "--- delta instructions ---\n\n")
+ fmt.Fprintf(w, "base size: %s (%d bytes)\n", formatBytes(int64(info.BaseSize)), info.BaseSize)
+ fmt.Fprintf(w, "target size: %s (%d bytes)\n", formatBytes(int64(info.TargetSize)), info.TargetSize)
+ fmt.Fprintf(w, "operations: %d\n\n", len(info.Ops))
+
+ for i, op := range info.Ops {
+ switch op.Kind {
+ case "copy":
+ fmt.Fprintf(w, "%4d copy base[%d:%d] (%d bytes)\n",
+ i, op.Offset, op.Offset+op.Size, op.Size)
+ case "insert":
+ if isBinary(op.Data) {
+ if entries, prefix, suffix := tryParseTreeInsert(op.Data); len(entries) > 0 || len(prefix) > 0 {
+ fmt.Fprintf(w, "%4d insert %d bytes (tree data)\n", i, op.Size)
+ if len(prefix) > 0 {
+ writeHashFragment(w, prefix, hashSet, repo, key)
+ }
+ for _, e := range entries {
+ hashStr := e.Hash.String()
+ typeStr := "blob"
+ if e.Mode == 0o40000 {
+ typeStr = "tree"
+ } else if e.Mode == 0o160000 {
+ typeStr = "commit"
+ }
+ name := htmlEscape(string(e.Name))
+ if hashSet[hashStr] {
+ href := fmt.Sprintf("/pack/%s/%s?key=%s", url.PathEscape(repo), hashStr, key)
+ fmt.Fprintf(w, " %06o %s %s\t%s\n", e.Mode, typeStr, href, hashStr, name)
+ } else {
+ fmt.Fprintf(w, " %06o %s %s\t%s\n", e.Mode, typeStr, hashStr, name)
+ }
+ }
+ if len(suffix) > 0 {
+ writeHashFragment(w, suffix, hashSet, repo, key)
+ }
+ } else {
+ fmt.Fprintf(w, "%4d insert %d bytes\n", i, op.Size)
+ writeHexDump(w, op.Data)
+ }
+ } else {
+ fmt.Fprintf(w, "%4d insert %d bytes: ", i, op.Size)
+ show := op.Data
+ truncated := false
+ if len(show) > 128 {
+ show = show[:128]
+ truncated = true
+ }
+ esc := &dumbEscaper{buf: bufio.NewWriter(w)}
+ esc.Write(show)
+ if truncated {
+ fmt.Fprintf(w, "...")
+ }
+ fmt.Fprintf(w, "\n")
+ }
+ }
+ }
+}
+
+// tryParseTreeInsert tries to interpret binary insert data as tree entry fragments.
+// It returns any complete tree entries parsed, plus any leading prefix (trailing
+// hash bytes from a previous entry) and trailing suffix that didn't form a complete entry.
+func tryParseTreeInsert(data []byte) (entries []gitfs.DirEntry, prefix, suffix []byte) {
+ // The insert might start mid-entry — the leading bytes could be the tail
+ // of a previous entry's 20-byte hash. Look for the start of a tree entry:
+ // an octal digit followed eventually by ' ', name, '\0', 20 bytes.
+ start := 0
+ for start < len(data) {
+ if data[start] >= '1' && data[start] <= '7' {
+ // Might be the start of a mode. Try parsing.
+ e, size := gitfs.ParseDirEntry(data[start:])
+ if size > 0 {
+ // Found a valid entry start. Everything before it is prefix.
+ if start > 0 {
+ prefix = data[:start]
+ }
+ entries = append(entries, e)
+ pos := start + size
+ // Parse remaining entries.
+ for pos < len(data) {
+ e, size := gitfs.ParseDirEntry(data[pos:])
+ if size == 0 {
+ break
+ }
+ entries = append(entries, e)
+ pos += size
+ }
+ if pos < len(data) {
+ suffix = data[pos:]
+ }
+ return entries, prefix, suffix
+ }
+ }
+ start++
+ }
+ // Couldn't parse any entries. Might be a pure hash fragment.
+ if len(data) <= 20 {
+ return nil, data, nil
+ }
+ return nil, nil, nil
+}
+
+func writeHashFragment(w io.Writer, data []byte, hashSet map[string]bool, repo, key string) {
+ if len(data) == 20 {
+ hashStr := fmt.Sprintf("%x", data)
+ if hashSet[hashStr] {
+ href := fmt.Sprintf("/pack/%s/%s?key=%s", url.PathEscape(repo), hashStr, key)
+ fmt.Fprintf(w, " hash %s\n", href, hashStr)
+ } else {
+ fmt.Fprintf(w, " hash %s\n", hashStr)
+ }
+ } else {
+ fmt.Fprintf(w, " (%d bytes) %x\n", len(data), data)
+ }
+}
+
+func isBinary(data []byte) bool {
+ for _, b := range data {
+ if b == 0 || b >= 0x7f {
+ return true
+ }
+ if b < 0x20 && b != '\n' && b != '\r' && b != '\t' {
+ return true
+ }
+ }
+ return false
+}
+
+func writeHexDump(w io.Writer, data []byte) {
+ for i := 0; i < len(data); i += 16 {
+ end := i + 16
+ if end > len(data) {
+ end = len(data)
+ }
+ line := data[i:end]
+
+ // Offset.
+ fmt.Fprintf(w, " %04x ", i)
+
+ // Hex bytes.
+ for j, b := range line {
+ if j == 8 {
+ fmt.Fprintf(w, " ")
+ }
+ fmt.Fprintf(w, "%02x ", b)
+ }
+ // Pad if short line.
+ for j := len(line); j < 16; j++ {
+ if j == 8 {
+ fmt.Fprintf(w, " ")
+ }
+ fmt.Fprintf(w, " ")
+ }
+
+ // ASCII.
+ fmt.Fprintf(w, " |")
+ for _, b := range line {
+ if b >= 0x20 && b < 0x7f {
+ fmt.Fprintf(w, "%c", b)
+ } else {
+ fmt.Fprintf(w, ".")
+ }
+ }
+ fmt.Fprintf(w, "|\n")
+ }
+}
+
+func formatBytes(b int64) string {
+ switch {
+ case b >= 1<<30:
+ return fmt.Sprintf("%.1f GiB", float64(b)/(1<<30))
+ case b >= 1<<20:
+ return fmt.Sprintf("%.1f MiB", float64(b)/(1<<20))
+ case b >= 1<<10:
+ return fmt.Sprintf("%.1f KiB", float64(b)/(1<<10))
+ default:
+ return fmt.Sprintf("%d B", b)
+ }
+}
diff --git a/internal/git/packfile.go b/internal/git/packfile.go
new file mode 100644
index 00000000..38501aa5
--- /dev/null
+++ b/internal/git/packfile.go
@@ -0,0 +1,442 @@
+package git
+
+import (
+ "bytes"
+ "compress/zlib"
+ "crypto/sha1"
+ "encoding/binary"
+ "encoding/hex"
+ "fmt"
+ "io"
+
+ "github.com/jonjohnsonjr/dagdotdev/internal/forks/rsc.io/gitfs"
+)
+
+type PackIndex struct {
+ Version uint32 `json:"version"`
+ NumObjects uint32 `json:"numObjects"`
+ Size int64 `json:"size"`
+ Checksum string `json:"checksum"`
+ Objects []PackObject `json:"objects"`
+}
+
+type PackObject struct {
+ Offset int `json:"offset"`
+ EncodedSize int `json:"encodedSize"`
+ Type string `json:"type"` // raw type: commit, tree, blob, tag, ofs-delta, ref-delta
+ ResolvedType string `json:"resolvedType"` // resolved type after delta resolution
+ Size int `json:"size"`
+ Hash string `json:"hash"`
+
+ // Delta info (only for ofs-delta and ref-delta objects)
+ DeltaBase string `json:"deltaBase,omitempty"` // raw base ref (hash for ref-delta, offset string for ofs-delta)
+ BaseHash string `json:"baseHash,omitempty"` // resolved base object hash
+ BaseOffset int `json:"baseOffset,omitempty"`
+ Depth int `json:"depth,omitempty"` // delta chain depth (0 for non-delta)
+}
+
+// BuildPackIndex parses a raw packfile and builds an index of all objects.
+func BuildPackIndex(data []byte) (*PackIndex, error) {
+ if len(data) < 12+20 {
+ return nil, fmt.Errorf("packfile too short")
+ }
+
+ hdr := data[:12]
+ vers := binary.BigEndian.Uint32(hdr[4:8])
+ nobj := binary.BigEndian.Uint32(hdr[8:12])
+ if string(hdr[:4]) != "PACK" || (vers != 2 && vers != 3) {
+ return nil, fmt.Errorf("not a packfile")
+ }
+ if vers == 3 {
+ return nil, fmt.Errorf("packfile v3 not supported")
+ }
+
+ sum := sha1.Sum(data[:len(data)-20])
+ if !bytes.Equal(sum[:], data[len(data)-20:]) {
+ return nil, fmt.Errorf("packfile checksum mismatch")
+ }
+
+ idx := &PackIndex{
+ Version: vers,
+ NumObjects: nobj,
+ Size: int64(len(data)),
+ Checksum: hex.EncodeToString(data[len(data)-20:]),
+ Objects: make([]PackObject, 0, nobj),
+ }
+
+ // We need a store to resolve delta chains and compute hashes.
+ var s gitfs.Store
+ objs := data[12 : len(data)-20]
+ off := 0
+
+ for i := 0; i < int(nobj); i++ {
+ obj, encSize, err := indexObject(&s, objs, off)
+ if err != nil {
+ return nil, fmt.Errorf("object %d at offset %d: %v", i, off+12, err)
+ }
+ obj.Offset = off + 12 // offset from start of packfile
+ obj.EncodedSize = encSize
+ idx.Objects = append(idx.Objects, obj)
+ off += encSize
+ }
+
+ // Compute delta chain depths.
+ byHash := map[string]int{} // hash -> index into Objects
+ for i, obj := range idx.Objects {
+ byHash[obj.Hash] = i
+ }
+ for i := range idx.Objects {
+ if idx.Objects[i].BaseHash == "" {
+ continue
+ }
+ depth := 1
+ baseHash := idx.Objects[i].BaseHash
+ for {
+ bi, ok := byHash[baseHash]
+ if !ok || idx.Objects[bi].BaseHash == "" {
+ break
+ }
+ depth++
+ baseHash = idx.Objects[bi].BaseHash
+ }
+ idx.Objects[i].Depth = depth
+ }
+
+ return idx, nil
+}
+
+// indexObject parses the object at objs[off:] and returns structural info.
+func indexObject(s *gitfs.Store, objs []byte, off int) (PackObject, int, error) {
+ if off < 0 || off >= len(objs) {
+ return PackObject{}, 0, fmt.Errorf("invalid offset")
+ }
+
+ u, size := binary.Uvarint(objs[off:])
+ if size <= 0 {
+ return PackObject{}, 0, fmt.Errorf("bad varint")
+ }
+ typ := gitfs.ObjType((u >> 4) & 7)
+ n := int(u&15 | u>>7<<4)
+
+ obj := PackObject{}
+
+ switch typ {
+ case gitfs.ObjRefDelta:
+ if len(objs)-(off+size) < 20 {
+ return PackObject{}, 0, fmt.Errorf("bad ref-delta")
+ }
+ var h gitfs.Hash
+ copy(h[:], objs[off+size:])
+ size += 20
+ obj.Type = "ref-delta"
+ obj.DeltaBase = h.String()
+
+ case gitfs.ObjOfsDelta:
+ i := off + size
+ if len(objs)-i < 20 {
+ return PackObject{}, 0, fmt.Errorf("bad ofs-delta")
+ }
+ d := int64(objs[i] & 0x7f)
+ for objs[i]&0x80 != 0 {
+ i++
+ d = d<<7 | int64(objs[i]&0x7f)
+ d += 1 << 7
+ }
+ i++
+ size = i - off
+ obj.Type = "ofs-delta"
+ obj.BaseOffset = off - int(d) + 12 // offset from start of packfile
+ obj.DeltaBase = fmt.Sprintf("-%d", int(d))
+
+ case gitfs.ObjCommit:
+ obj.Type = "commit"
+ case gitfs.ObjTree:
+ obj.Type = "tree"
+ case gitfs.ObjBlob:
+ obj.Type = "blob"
+ case gitfs.ObjTag:
+ obj.Type = "tag"
+ default:
+ return PackObject{}, 0, fmt.Errorf("unknown type %d", typ)
+ }
+
+ // Decompress to get the actual size and compute hash.
+ br := bytes.NewReader(objs[off+size:])
+ zr, err := zlib.NewReader(br)
+ if err != nil {
+ return PackObject{}, 0, fmt.Errorf("zlib: %v", err)
+ }
+ content, err := io.ReadAll(zr)
+ if err != nil {
+ return PackObject{}, 0, fmt.Errorf("zlib read: %v", err)
+ }
+ if len(content) != n {
+ return PackObject{}, 0, fmt.Errorf("size mismatch: %d != %d", len(content), n)
+ }
+ encSize := len(objs[off:]) - br.Len()
+
+ // For non-delta objects, the hash is straightforward.
+ // For delta objects, we need to resolve the chain via the store.
+ switch typ {
+ case gitfs.ObjCommit, gitfs.ObjTree, gitfs.ObjBlob, gitfs.ObjTag:
+ h, _ := s.Add(typ, content)
+ obj.Hash = h.String()
+ obj.Size = len(content)
+ obj.ResolvedType = obj.Type
+
+ case gitfs.ObjRefDelta:
+ baseTyp, baseData := s.Object(gitfs.Hash(mustParseHash(obj.DeltaBase)))
+ if baseTyp == gitfs.ObjNone {
+ return PackObject{}, 0, fmt.Errorf("unknown ref-delta base %s", obj.DeltaBase)
+ }
+ resolved, err := applyPackDelta(baseData, content)
+ if err != nil {
+ return PackObject{}, 0, fmt.Errorf("apply ref-delta: %v", err)
+ }
+ h, _ := s.Add(baseTyp, resolved)
+ obj.Hash = h.String()
+ obj.Size = len(resolved)
+ obj.ResolvedType = baseTyp.String()
+ obj.BaseHash = obj.DeltaBase
+
+ case gitfs.ObjOfsDelta:
+ baseOff := off - mustParseOfsOffset(obj.DeltaBase)
+ baseTyp, baseHash, baseContent, _, err := gitfs.UnpackObject(s, objs, baseOff)
+ if err != nil {
+ return PackObject{}, 0, fmt.Errorf("resolve ofs-delta base: %v", err)
+ }
+ resolved, err := applyPackDelta(baseContent, content)
+ if err != nil {
+ return PackObject{}, 0, fmt.Errorf("apply ofs-delta: %v", err)
+ }
+ h, _ := s.Add(baseTyp, resolved)
+ obj.Hash = h.String()
+ obj.Size = len(resolved)
+ obj.ResolvedType = baseTyp.String()
+ obj.BaseHash = baseHash.String()
+ }
+
+ return obj, encSize, nil
+}
+
+func mustParseHash(s string) [20]byte {
+ b, _ := hex.DecodeString(s)
+ var h [20]byte
+ copy(h[:], b)
+ return h
+}
+
+func mustParseOfsOffset(s string) int {
+ // s is like "-1234"
+ var n int
+ fmt.Sscanf(s, "-%d", &n)
+ return n
+}
+
+// resolveBaseType follows the delta chain to find the base object type.
+func resolveBaseType(s *gitfs.Store, objs []byte, off int) (gitfs.ObjType, error) {
+ u, size := binary.Uvarint(objs[off:])
+ if size <= 0 {
+ return 0, fmt.Errorf("bad varint")
+ }
+ typ := gitfs.ObjType((u >> 4) & 7)
+ switch typ {
+ case gitfs.ObjCommit, gitfs.ObjTree, gitfs.ObjBlob, gitfs.ObjTag:
+ return typ, nil
+ case gitfs.ObjOfsDelta:
+ i := off + size
+ d := int64(objs[i] & 0x7f)
+ for objs[i]&0x80 != 0 {
+ i++
+ d = d<<7 | int64(objs[i]&0x7f)
+ d += 1 << 7
+ }
+ return resolveBaseType(s, objs, off-int(d))
+ case gitfs.ObjRefDelta:
+ var h gitfs.Hash
+ copy(h[:], objs[off+size:])
+ baseTyp, _ := s.Object(h)
+ return baseTyp, nil
+ }
+ return 0, fmt.Errorf("unknown type %d", typ)
+}
+
+// applyPackDelta applies a delta to a base to produce the target.
+func applyPackDelta(base, delta []byte) ([]byte, error) {
+ // Delta starts with base size and target size as varints.
+ baseSize, s := binary.Uvarint(delta)
+ delta = delta[s:]
+ if baseSize != uint64(len(base)) {
+ return nil, fmt.Errorf("base size mismatch: %d != %d", baseSize, len(base))
+ }
+ targSize, s := binary.Uvarint(delta)
+ delta = delta[s:]
+
+ targ := make([]byte, targSize)
+ dst := targ
+ for len(delta) > 0 {
+ cmd := delta[0]
+ delta = delta[1:]
+ switch {
+ case cmd == 0:
+ return nil, fmt.Errorf("invalid delta cmd")
+ case cmd&0x80 != 0:
+ var off, size int64
+ for i := uint(0); i < 4; i++ {
+ if cmd&(1<Explore the raw packfile format of a git repo:
+ ++