commit 9f107b5f80cd05e1b9882d69d6acbc8d34eb485c
Author: David Gwilliam <dhgwilliam@gmail.com>
Date:   Mon Jun 15 22:33:53 2026 -0700

    Initial commit: akai-fetch - AKAI sampler ISO downloader & extractor
    
    - fetch: Go CLI tool for searching, downloading, and extracting
      AKAI sampler ISOs from archive.org
    - scripts/extract_wavs.sh: Shell script driving akaiutil to
      convert samples to WAV
    - Dockerfile: Multi-stage build packaging akaiutil + fetch
    - third_party/akaiutil: Vendored akaiutil v4.6.7 source (GPLv2)
    - docs/akaiutil.md: Full akaiutil reference

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6e872b8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,28 @@
+# Binaries
+fetch
+akai-fetch
+akai-fetch-bin
+*.exe
+
+# Original akaiutil source (vendored copy in third_party/)
+akaiutil-4.6.7/
+
+# Build artifacts
+*.o
+*.obj
+
+# Data
+*.iso
+output/
+wavs
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temp
+/tmp/
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..524bc90
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,33 @@
+# Stage 1: Build akaiutil from source
+FROM debian:11 AS akaiutil-builder
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY third_party/akaiutil/ /src/akaiutil/
+WORKDIR /src/akaiutil
+RUN make
+
+# Stage 2: Build fetch (Go tool)
+FROM golang:1.26-alpine AS fetch-builder
+
+WORKDIR /src
+COPY go.mod main.go /src/
+RUN CGO_ENABLED=0 go build -o /fetch .
+
+# Stage 3: Runtime image
+FROM debian:11-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=akaiutil-builder /src/akaiutil/akaiutil /usr/local/bin/
+COPY --from=fetch-builder /fetch /usr/local/bin/fetch
+COPY scripts/extract_wavs.sh /usr/local/bin/
+
+WORKDIR /data
+ENTRYPOINT ["fetch"]
+CMD ["--help"]
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..0637910
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,21 @@
+BIN := fetch
+IMAGE := akai-fetch
+REMOTE := dhg.lol
+
+build:
+	CGO_ENABLED=0 go build -o $(BIN) .
+
+docker:
+	docker build -t $(IMAGE) .
+
+docker-run:
+	docker run --rm -v "$(PWD)/output:/data" $(IMAGE) $(ARGS)
+
+install: build
+	scp $(BIN) $(REMOTE):/tmp/$(BIN) && \
+	ssh $(REMOTE) "sudo mv /tmp/$(BIN) /DATA/Downloads/akai/$(BIN) && sudo chmod +x /DATA/Downloads/akai/$(BIN)"
+
+clean:
+	rm -f $(BIN)
+
+.PHONY: build docker docker-run install clean
diff --git a/docs/akaiutil.md b/docs/akaiutil.md
new file mode 100644
index 0000000..6eec08a
--- /dev/null
+++ b/docs/akaiutil.md
@@ -0,0 +1,219 @@
+# akaiutil — AKAI Sampler Filesystem Tool
+
+**Version 4.6.7** (21-OCT-2022) — GPLv2 — by Klaus Michael Indlekofer
+
+Interactive console-based file manager for AKAI **S900/S950/S1000/S1100/S3000/CD3000** sampler disk images, floppies, hard drives, and CD-ROMs.
+
+## Usage
+
+```
+akaiutil [-h] [-r] [-F] [-C] [-l <lock-file>] [-o <start-offset>] [-s <pseudo-disk-size>]
+         [-n <pseudo-disk-number>] [-c <cdrom-index> ...] [-p <physdrive-index> ...]
+         [[-f] <floppy-drive>] ... [[-f] <disk-file>] ...
+```
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `-h` | Print help |
+| `-r` | Read-only mode (must come first) |
+| `-F` | Disable floppy filesystem detection |
+| `-C` | Disable block cache |
+| `-l <file>` | Lock file for exclusive access |
+| `-o <offset>` | Byte offset where disk data starts (decimal or `0x` hex) |
+| `-s <size>` | Pseudo-disk size in KB (for multi-disk images) |
+| `-n <num>` | Max pseudo-disks per file descriptor (max 8) |
+| `-c <n>` | (Windows) Open CD-ROM `\\.\cdromN` |
+| `-p <n>` | (Windows) Open physical drive `\\.\physicaldriveN` |
+
+On Linux, pass raw devices like `/dev/da1`, `/dev/disk2s0`.
+
+### Examples
+
+```bash
+# Open a floppy image
+akaiutil fff.img
+
+# Open harddisk images
+akaiutil hhh1.img hhh2.img
+
+# Multi-harddisk image with explicit size
+akaiutil -s 524280 mmm.img
+
+# Linux raw device access
+akaiutil /dev/da1 hhh.img
+
+# Read-only CD-ROM (macOS)
+akaiutil -r /dev/disk2s0
+```
+
+## Virtual Filesystem
+
+```
+/disk<N>/<partition-letter>/<volume-name>/<file-name>
+```
+
+Shorthand: `/N` = `/diskN`, `/floppyN` = `/diskN/A/<volume1>`. Use `_` for spaces in names. `.` and `..` work as usual.
+
+## Interactive Commands
+
+### Navigation & Info
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `help [<cmd>]` | `man` | List commands or show help for a command |
+| `exit` / `quit` | `bye`, `q` | Exit |
+| `restart` | — | Rescan disks |
+| `restartkeep` | `restart.`, `sync` | Rescan, keep current directory |
+| `df` | — | Show disk info (all disks + partitions) |
+| `dinfo` | `pwd` | Show current directory info |
+| `cd [<path>]` | — | Change directory |
+| `cdi <index>` | — | Change to volume by index |
+| `dir [<path>]` | `ls` | List directory |
+| `dirrec` | `lsrec` | Recursive listing |
+| `lcd <path>` | — | Change local (host) directory |
+| `ldir` | `lls` | List local directory |
+| `dircache` | `lscache` | Show block cache info |
+
+### File Operations
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `del <path>` / `deli <idx>` | `rm` / `rmi` | Delete file |
+| `ren <old> <new> [<idx>]` | `mv` | Rename/move file |
+| `reni <old-idx> <new> [<idx>]` | `mvi` | Rename by index |
+| `copy <src> <dst> [<idx>]` | `cp` | Copy file |
+| `copyi <src-idx> <dst> [<idx>]` | `cpi` | Copy by index |
+| `infoi <idx>` | — | Show file info |
+| `infoall` | — | Show info for all files |
+
+### Import / Export
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `get <path> [<begin> [<end>]]` | `export` | Export file to host |
+| `geti <idx> [<begin> [<end>]]` | `exporti` | Export by index |
+| `getall` | `exportall` | Export all files |
+| `put [<vol>/]<name> [<idx>]` | `import` | Import file (use `*` for all) |
+| `getdisk <file>` | `dget`, `dexport` | Export entire disk image |
+| `putdisk <file>` | `dput`, `dimport` | Import disk image |
+| `getpart [<path>] <file>` | `pget`, `pexport` | Export partition |
+| `putpart <file> [<path>]` | `pput`, `pimport` | Import partition |
+| `gettags <file>` | `tagsget` | Export partition tags |
+| `puttags <file>` | `tagsput` | Import partition tags |
+
+### WAV Conversion
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `sample2wav <path>` / `sample2wavi <idx>` | `s2wav` / `getwav` | Sample → WAV |
+| `sample2wavall` | `s2wavall` | All samples → WAV |
+| `wav2sample <file> [<idx>]` | `wav2s`, `putwav` | WAV → sample (auto-detect) |
+| `wav2sample9` / `wav2sample9c` | `putwav9` / `putwav9c` | WAV → S900 (non-compressed / compressed) |
+| `wav2sample1` | `putwav1` | WAV → S1000 |
+| `wav2sample3` | `putwav3` | WAV → S3000 |
+
+WAV input must be mono/stereo, 8/16/24/32-bit PCM.
+
+### S900 Compression
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `sample900compr <path>` | `s9compr` | Compress S900 sample |
+| `sample900comprall` | `s9comprall` | Compress all S900 samples |
+| `sample900uncompr <path>` | `s9uncompr` | Uncompress S900 sample |
+| `sample900uncomprall` | `s9uncomprall` | Uncompress all |
+
+### Volume Management
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `mkvol [<path>]` | `mkdir` | Create volume (auto-detect type) |
+| `mkvol9` / `mkvol1` / `mkvol3` / `mkvol3cd` | `mkdir9` etc. | Create S900/S1000/S3000/CD3000 volume |
+| `mkvoli <idx> [<name> [<load-num>]]` | `mkdiri` | Create volume at specific index |
+| `delvol <path>` / `delvoli <idx>` | `rmdir` | Delete volume |
+| `wipevol <path>` / `wipevoli <idx>` | `rmall` | Wipe all files in volume |
+| `renvol <old> <new>` | `mvdir` | Rename volume |
+| `copyvol <src> <dst>` / `copyvoli <idx> <dst>` | `cpvol` | Copy volume |
+| `copypart <src> <dst>` | `cppart` | Copy all volumes of a partition |
+| `setosvervol <ver>` / `setlnum <num>` | — | Set volume OS version / load number |
+| `fixramname <path>` / `fixramnameall` | — | Fix file name headers |
+
+### Volume Parameters
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `lsparam` / `lsparami <idx>` | — | List parameters |
+| `initparam` / `initparami <idx>` | — | Initialize parameters |
+| `setparam <idx> <val>` / `setparami <vidx> <pidx> <val>` | — | Set parameter |
+| `getparam <file>` / `putparam <file>` | `paramget` / `paramput` | Export/import parameters |
+
+### Tag Management
+
+| Command | Description |
+|---------|-------------|
+| `lstags` | List tags |
+| `inittags` | Initialize all tags |
+| `rentag <idx> <name>` | Rename a tag |
+| `settagi <file-idx> <tag-idx>` / `settagall <tag-idx>` | Tag a file / all files |
+| `clrtagi <file-idx> <tag-idx or all>` / `clrtagall <tag or all>` | Untag |
+| `setfiltertag <idx>` / `clrfiltertag <idx or all>` | Filter by tag |
+
+### Formatting / Filesystem Operations
+
+| Command | Description |
+|---------|-------------|
+| `formatfloppyl9` / `l1` / `l3` | Format low-density floppy for S900/S1000/S3000 |
+| `formatfloppyh9` / `h1` / `h3` | Format high-density floppy |
+| `wipefloppy` | Create filesystem on floppy |
+| `formatharddisk9 [<size>]` | Format HD for S900 (SH205, SUPRA20M, SUPRA30M, SUPRA60M, or size) |
+| `formatharddisk1 [<part-size> [<total-size>]]` | Format HD for S1000 |
+| `formatharddisk3 [<part-size> [<total-size>]]` | Format HD for S3000 |
+| `formatharddisk3cd [<part-size> [<total-size>]]` | Format CD3000 CD-ROM |
+| `wipepart` / `wipepart3cd` | Create filesystem in partition |
+| `fixpart` / `fixharddisk` | Fix filesystem |
+| `scanbadblkspart` / `scanbadblksdisk` | Scan for bad blocks |
+| `markbadblkspart` / `markbadblksdisk` | Mark free bad blocks |
+| `setcdinfo [<label>]` / `cdinfo` / `vcdinfo` | CD3000 CD-ROM info |
+
+### FAT / Direct-to-Disk Takes
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `tinfoi <idx>` / `tinfoall` | — | DD take info |
+| `tdeli <idx>` | `trmi` | Delete DD take |
+| `treni <idx> <name>` | `tmvi` | Rename DD take |
+| `tgeti <idx>` / `tgetall` | `texporti` | Export DD take (`.TK`) |
+| `tput <file>` | `timport` | Import DD take (`*.TK` for all) |
+| `take2wavi <idx>` / `take2wavall` | `t2wavi`, `getwavti` | DD take → WAV |
+| `wav2take <file>` | `wav2t`, `putwavt` | WAV → DD take |
+
+### Tar Archives
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `tarc <file>` | `gettar` | Create tar from current directory |
+| `tarcwav <file>` | `gettarwav` | Tar-create with WAV conversion |
+| `tarx <file>` | `puttar` | Extract tar (auto-detect type) |
+| `tarx9` / `tarx1` / `tarx3` / `tarx3cd` | `puttar9` etc. | Extract as specific type |
+| `tarxwav` | `puttarwav` | Extract with WAV → sample conversion |
+| `tarxwav9` / `tarxwav9c` / `tarxwav1` / `tarxwav3` | — | Extract WAV as specific sampler type |
+
+## Filesystem Types
+
+| Type | Description | Block Size | Max Size / Blocks |
+|------|-------------|------------|-------------------|
+| FLL | Low-density floppy | 1 KB | 800 KB (800 blocks) |
+| FLH | High-density floppy | 1 KB | 1600 KB (1600 blocks) |
+| HD9 | S900/S950 harddisk | 8 KB | ~64 MB (8191 blocks) |
+| HD | S1000/S3000 partition | 8 KB | 60 MB/partition, ~512 MB total |
+| DD | S1100/S3000 Direct-to-Disk | 8 KB | ~512 MB |
+
+## Build
+
+```bash
+make
+```
+
+Produces the `akaiutil` binary.
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..490dec9
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,3 @@
+module akai-fetch
+
+go 1.26
diff --git a/main.go b/main.go
new file mode 100644
index 0000000..2c99fd6
--- /dev/null
+++ b/main.go
@@ -0,0 +1,596 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	iaSearchURL = "https://archive.org/advancedsearch.php"
+	iaBaseURL   = "https://archive.org"
+	userAgent   = "akai-fetch/1.0"
+)
+
+type SearchResult struct {
+	Response struct {
+		NumFound int            `json:"numFound"`
+		Docs     []SearchDoc    `json:"docs"`
+	} `json:"response"`
+}
+
+type SearchDoc struct {
+	Identifier  string   `json:"identifier"`
+	Title       string   `json:"title"`
+	Downloads   int      `json:"downloads"`
+	Format      []string `json:"format"`
+}
+
+type MetadataResult struct {
+	Files []MetadataFile `json:"files"`
+}
+
+type MetadataFile struct {
+	Name   string `json:"name"`
+	Size   string `json:"size"`
+	Format string `json:"format"`
+	Source string `json:"source"`
+}
+
+func main() {
+	if len(os.Args) < 2 {
+		printUsage()
+		os.Exit(1)
+	}
+
+	cmd := os.Args[1]
+	args := os.Args[2:]
+
+	switch cmd {
+	case "search":
+		cmdSearch(args)
+	case "list":
+		cmdList(args)
+	case "download":
+		cmdDownload(args)
+	case "extract":
+		cmdExtract(args)
+	case "pipeline":
+		cmdPipeline(args)
+	default:
+		fmt.Fprintf(os.Stderr, "unknown command: %s\n", cmd)
+		printUsage()
+		os.Exit(1)
+	}
+}
+
+func printUsage() {
+	fmt.Println(`akai-fetch — AKAI sampler ISO downloader & extractor
+
+Usage:
+  akai-fetch search [flags]             search archive.org for AKAI sampler ISOs
+  akai-fetch list <identifier>          list downloadable ISO files in an item
+  akai-fetch download [flags]           download ISOs (from file or by identifier)
+  akai-fetch extract [flags]            extract WAVs from downloaded ISOs
+  akai-fetch pipeline [flags]           full search → download → extract pipeline
+
+Search flags:
+  -query "akai sampler"    search query (default: "subject:akai AND subject:sampler")
+  -filter "term"           extra term AND-ed onto the query (e.g. "vocal")
+  -limit 30                max results (default: 30)
+  -min-downloads 0         minimum download count filter
+
+Download flags:
+  -i "identifier"          archive.org item identifier
+  -f "file.txt"            file with list of identifiers (one per line)
+  -dir "./isos"            output directory (default: current dir)
+  -jobs 2                  concurrent downloads (default: 2)
+
+Extract flags:
+  -dir "./isos"            directory containing ISO files
+  -out "./wavs"            output directory for WAV files
+  -tool "./extract_wavs.sh" path to extraction script
+  -jobs 2                  concurrent extractions (default: 2)
+
+Pipeline flags:
+  -query "akai sampler"    search query (default: "subject:akai AND subject:sampler")
+  -filter "term"           extra term AND-ed onto the query
+  -limit 30                max results
+  -dir "./output"          base output directory
+  -download-jobs 2         concurrent downloads
+  -extract-jobs 2          concurrent extractions`)
+}
+
+// ─── Search ────────────────────────────────────────────────────────────
+
+func cmdSearch(args []string) {
+	fs := flag.NewFlagSet("search", flag.ExitOnError)
+	query := fs.String("query", "subject:akai AND subject:sampler", "search query")
+	filter := fs.String("filter", "", "extra term AND-ed onto the query")
+	limit := fs.Int("limit", 30, "max results")
+	minDL := fs.Int("min-downloads", 0, "minimum download count")
+	_ = fs.Parse(args)
+
+	q := *query
+	if *filter != "" {
+		q = "(" + q + ") AND (" + *filter + ")"
+	}
+
+	results := searchArchive(q, *limit)
+	sort.Slice(results, func(i, j int) bool {
+		return results[i].Downloads > results[j].Downloads
+	})
+
+	fmt.Printf("Found %d items:\n\n", len(results))
+	for _, r := range results {
+		if *minDL > 0 && r.Downloads < *minDL {
+			continue
+		}
+		fmt.Printf("  %-40s  downloads: %-8d  title: %s\n", r.Identifier, r.Downloads, truncate(r.Title, 50))
+	}
+}
+
+func searchArchive(query string, limit int) []SearchDoc {
+	params := url.Values{}
+	params.Set("q", query)
+	params.Set("fl[]", "identifier,title,downloads,format")
+	params.Set("sort[]", "downloads desc")
+	params.Set("rows", strconv.Itoa(limit))
+	params.Set("page", "1")
+	params.Set("output", "json")
+
+	u := iaSearchURL + "?" + params.Encode()
+	client := &http.Client{Timeout: 30 * time.Second}
+	req, err := http.NewRequest("GET", u, nil)
+	if err != nil {
+		fatal("http request: %v", err)
+	}
+	req.Header.Set("User-Agent", userAgent)
+	resp, err := client.Do(req)
+	if err != nil {
+		fatal("search request: %v", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		fatal("read response: %v", err)
+	}
+
+	var sr SearchResult
+	if err := json.Unmarshal(body, &sr); err != nil {
+		fatal("parse response: %v", err)
+	}
+	return sr.Response.Docs
+}
+
+// ─── List ──────────────────────────────────────────────────────────────
+
+func cmdList(args []string) {
+	if len(args) < 1 {
+		fatal("usage: akai-fetch list <identifier>")
+	}
+	identifier := args[0]
+	files := getItemFiles(identifier)
+
+	fmt.Printf("Files in %s:\n\n", identifier)
+	for _, f := range files {
+		size := f.Size
+		if size == "" {
+			size = "?"
+		}
+		fmt.Printf("  %-60s  %s\n", f.Name, size)
+	}
+}
+
+func getItemFiles(identifier string) []MetadataFile {
+	u := fmt.Sprintf("%s/metadata/%s", iaBaseURL, url.PathEscape(identifier))
+	client := &http.Client{Timeout: 30 * time.Second}
+	req, _ := http.NewRequest("GET", u, nil)
+	req.Header.Set("User-Agent", userAgent)
+	resp, err := client.Do(req)
+	if err != nil {
+		fatal("metadata request: %v", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		fatal("read metadata: %v", err)
+	}
+
+	var mr struct {
+		Files []MetadataFile `json:"files"`
+	}
+	if err := json.Unmarshal(body, &mr); err != nil {
+		fatal("parse metadata: %v", err)
+	}
+
+	var isos []MetadataFile
+	for _, f := range mr.Files {
+		if strings.HasSuffix(strings.ToLower(f.Name), ".iso") {
+			isos = append(isos, f)
+		}
+	}
+	return isos
+}
+
+// ─── Download ──────────────────────────────────────────────────────────
+
+type downloadJob struct {
+	Identifier string
+	Name       string
+	URL        string
+	OutPath    string
+	Size       int64
+}
+
+func cmdDownload(args []string) {
+	fs := flag.NewFlagSet("download", flag.ExitOnError)
+	identifier := fs.String("i", "", "archive.org item identifier")
+	idFile := fs.String("f", "", "file with identifiers (one per line)")
+	outDir := fs.String("dir", ".", "output directory")
+	jobs := fs.Int("jobs", 2, "concurrent downloads")
+	_ = fs.Parse(args)
+
+	os.MkdirAll(*outDir, 0755)
+
+	var identifiers []string
+	if *identifier != "" {
+		identifiers = append(identifiers, *identifier)
+	}
+	if *idFile != "" {
+		data, err := os.ReadFile(*idFile)
+		if err != nil {
+			fatal("read id file: %v", err)
+		}
+		for _, line := range strings.Split(string(data), "\n") {
+			line = strings.TrimSpace(line)
+			if line != "" && !strings.HasPrefix(line, "#") {
+				identifiers = append(identifiers, line)
+			}
+		}
+	}
+
+	if len(identifiers) == 0 {
+		fatal("provide -i <identifier> or -f <file>")
+	}
+
+	var jobsList []downloadJob
+	for _, id := range identifiers {
+		files := getItemFiles(id)
+		if len(files) == 0 {
+			fmt.Printf("[%s] no ISO files found\n", id)
+			continue
+		}
+		for _, f := range files {
+			size, _ := strconv.ParseInt(f.Size, 10, 64)
+			jobsList = append(jobsList, downloadJob{
+				Identifier: id,
+				Name:       f.Name,
+				URL:        fmt.Sprintf("%s/download/%s/%s", iaBaseURL, url.PathEscape(id), url.PathEscape(f.Name)),
+				OutPath:    filepath.Join(*outDir, f.Name),
+				Size:       size,
+			})
+		}
+	}
+
+	if len(jobsList) == 0 {
+		fmt.Println("no download jobs")
+		return
+	}
+
+	fmt.Printf("Downloading %d file(s) with %d concurrent job(s)...\n\n", len(jobsList), *jobs)
+
+	var mu sync.Mutex
+	sem := make(chan struct{}, *jobs)
+	var wg sync.WaitGroup
+	var totalDownloaded int64
+
+	for _, job := range jobsList {
+		wg.Add(1)
+		go func(j downloadJob) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			size, err := downloadFile(j)
+			mu.Lock()
+			totalDownloaded += size
+			mu.Unlock()
+
+			if err != nil {
+				fmt.Printf("  FAIL  %-40s  %v\n", j.Name, err)
+			} else {
+				fmt.Printf("  OK    %-40s  %s\n", j.Name, humanSize(size))
+			}
+		}(job)
+	}
+	wg.Wait()
+	fmt.Printf("\nDownloaded %s total\n", humanSize(totalDownloaded))
+}
+
+func downloadFile(job downloadJob) (int64, error) {
+	// Check if file already exists and has the expected size
+	if fi, err := os.Stat(job.OutPath); err == nil {
+		if job.Size > 0 && fi.Size() == job.Size {
+			return fi.Size(), nil
+		}
+	}
+
+	// Check if partial file exists for resume
+	var existingSize int64
+	if fi, err := os.Stat(job.OutPath); err == nil {
+		existingSize = fi.Size()
+	}
+
+	client := &http.Client{Timeout: 0}
+	req, err := http.NewRequest("GET", job.URL, nil)
+	if err != nil {
+		return 0, fmt.Errorf("request: %w", err)
+	}
+	req.Header.Set("User-Agent", userAgent)
+	if existingSize > 0 {
+		req.Header.Set("Range", fmt.Sprintf("bytes=%d-", existingSize))
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, fmt.Errorf("get: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
+		return 0, fmt.Errorf("HTTP %d", resp.StatusCode)
+	}
+
+	outFile, err := os.OpenFile(job.OutPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+	if err != nil {
+		return 0, fmt.Errorf("open: %w", err)
+	}
+	defer outFile.Close()
+
+	written, err := io.Copy(outFile, resp.Body)
+	if err != nil {
+		return 0, fmt.Errorf("download: %w", err)
+	}
+	return written + existingSize, nil
+}
+
+// ─── Extract ───────────────────────────────────────────────────────────
+
+func cmdExtract(args []string) {
+	fs := flag.NewFlagSet("extract", flag.ExitOnError)
+	isoDir := fs.String("dir", ".", "directory with ISO files")
+	outDir := fs.String("out", "./wavs", "output directory for WAVs")
+	toolPath := fs.String("tool", "./extract_wavs.sh", "path to extraction script")
+	jobs := fs.Int("jobs", 2, "concurrent extractions")
+	_ = fs.Parse(args)
+
+	entries, err := os.ReadDir(*isoDir)
+	if err != nil {
+		fatal("read dir: %v", err)
+	}
+
+	var isos []string
+	for _, e := range entries {
+		if !e.IsDir() && strings.HasSuffix(strings.ToLower(e.Name()), ".iso") {
+			isos = append(isos, filepath.Join(*isoDir, e.Name()))
+		}
+	}
+
+	if len(isos) == 0 {
+		fmt.Println("no ISO files found in", *isoDir)
+		return
+	}
+
+	fmt.Printf("Extracting %d ISO(s) with %d concurrent job(s)...\n", len(isos), *jobs)
+
+	sem := make(chan struct{}, *jobs)
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	results := map[string]string{}
+
+	for _, iso := range isos {
+		wg.Add(1)
+		go func(isoPath string) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			out := *outDir
+			result, err := extractISO(*toolPath, isoPath, out)
+			mu.Lock()
+			results[filepath.Base(isoPath)] = result
+			mu.Unlock()
+			if err != nil {
+				fmt.Printf("  FAIL  %-40s  %v\n", filepath.Base(isoPath), err)
+			} else {
+				fmt.Printf("  OK    %-40s  %s\n", filepath.Base(isoPath), result)
+			}
+		}(iso)
+	}
+	wg.Wait()
+}
+
+func extractISO(toolPath, isoPath, outDir string) (string, error) {
+	absTool, err := filepath.Abs(toolPath)
+	if err != nil {
+		return "", err
+	}
+	if _, err := os.Stat(absTool); os.IsNotExist(err) {
+		return "", fmt.Errorf("script not found: %s", absTool)
+	}
+
+	isoOutDir := filepath.Join(outDir, sanitiseISOName(filepath.Base(isoPath)))
+
+	if _, err := os.Stat(isoOutDir); err == nil {
+		var wavCount int
+		filepath.WalkDir(isoOutDir, func(p string, d os.DirEntry, err error) error {
+			if err == nil && !d.IsDir() && strings.HasSuffix(strings.ToLower(d.Name()), ".wav") {
+				wavCount++
+			}
+			return nil
+		})
+		if wavCount > 0 {
+			return fmt.Sprintf("skipped (%d WAVs exist)", wavCount), nil
+		}
+	}
+
+	cmd := exec.Command("bash", absTool, isoPath, outDir)
+	cmd.Stderr = nil
+	output, err := cmd.Output()
+	if err != nil {
+		return "", fmt.Errorf("extract: %w", err)
+	}
+
+	lines := strings.Split(string(output), "\n")
+	for _, line := range lines {
+		if strings.Contains(line, "Total WAV files:") {
+			return strings.TrimSpace(line), nil
+		}
+	}
+	return "extracted (check output)", nil
+}
+
+func sanitiseISOName(path string) string {
+	name := path
+	if ext := filepath.Ext(name); ext != "" {
+		name = name[:len(name)-len(ext)]
+	}
+	// Matches extract_wavs.sh sanitisation
+	var buf strings.Builder
+	for _, r := range name {
+		if r == ' ' {
+			buf.WriteRune('_')
+		} else if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') ||
+			(r >= '0' && r <= '9') || r == '_' || r == '.' || r == '-' {
+			buf.WriteRune(r)
+		} else {
+			buf.WriteRune('_')
+		}
+	}
+	// Collapse multiple underscores
+	s := buf.String()
+	for strings.Contains(s, "__") {
+		s = strings.ReplaceAll(s, "__", "_")
+	}
+	// Strip leading/trailing _ and .
+	s = strings.Trim(s, "_.")
+	return s
+}
+
+// ─── Pipeline ──────────────────────────────────────────────────────────
+
+func cmdPipeline(args []string) {
+	fs := flag.NewFlagSet("pipeline", flag.ExitOnError)
+	query := fs.String("query", "subject:akai AND subject:sampler", "search query")
+	filter := fs.String("filter", "", "extra term AND-ed onto the query")
+	limit := fs.Int("limit", 10, "max results")
+	baseDir := fs.String("dir", "./output", "base output directory")
+	dlJobs := fs.Int("download-jobs", 2, "concurrent downloads")
+	extJobs := fs.Int("extract-jobs", 2, "concurrent extractions")
+	_ = fs.Parse(args)
+
+	isoDir := filepath.Join(*baseDir, "isos")
+	wavDir := filepath.Join(*baseDir, "wavs")
+	toolPath := filepath.Join(filepath.Dir(os.Args[0]), "extract_wavs.sh")
+
+	if _, err := os.Stat(toolPath); os.IsNotExist(err) {
+		cwd, _ := os.Getwd()
+		toolPath = filepath.Join(cwd, "extract_wavs.sh")
+	}
+
+	// Remaining args after flags are treated as explicit identifiers
+	identifiers := fs.Args()
+
+	if len(identifiers) == 0 {
+		fmt.Println("=== Phase 1: Search ===")
+		q := *query
+		if *filter != "" {
+			q = "(" + q + ") AND (" + *filter + ")"
+		}
+		fmt.Printf("Query: %s  Limit: %d\n\n", q, *limit)
+		results := searchArchive(q, *limit)
+		sort.Slice(results, func(i, j int) bool {
+			return results[i].Downloads > results[j].Downloads
+		})
+		if len(results) == 0 {
+			fmt.Println("No results found.")
+			return
+		}
+		for _, r := range results {
+			identifiers = append(identifiers, r.Identifier)
+		}
+		fmt.Printf("Found %d items\n\n", len(identifiers))
+	} else {
+		fmt.Printf("=== Processing %d specific item(s) ===\n\n", len(identifiers))
+	}
+
+	if err := os.MkdirAll(*baseDir, 0755); err != nil {
+		fatal("create output dir: %v", err)
+	}
+
+	idFile := filepath.Join(*baseDir, "identifiers.txt")
+	var idContent strings.Builder
+	for _, id := range identifiers {
+		idContent.WriteString(id + "\n")
+	}
+	if err := os.WriteFile(idFile, []byte(idContent.String()), 0644); err != nil {
+		fatal("write ids: %v", err)
+	}
+	fmt.Printf("Identifiers saved to %s\n\n", idFile)
+
+	fmt.Println("=== Phase 2: Download ===")
+	cmdDownload([]string{"-f", idFile, "-dir", isoDir, "-jobs", fmt.Sprintf("%d", *dlJobs)})
+
+	fmt.Println("\n=== Phase 3: Extract ===")
+	cmdExtract([]string{"-dir", isoDir, "-out", wavDir, "-tool", toolPath, "-jobs", fmt.Sprintf("%d", *extJobs)})
+
+	fmt.Printf("\n=== Pipeline Complete ===\n")
+	fmt.Printf("  ISOs: %s\n", isoDir)
+	fmt.Printf("  WAVs: %s\n", wavDir)
+}
+
+// ─── Helpers ───────────────────────────────────────────────────────────
+
+func fatal(format string, args ...any) {
+	fmt.Fprintf(os.Stderr, "error: "+format+"\n", args...)
+	os.Exit(1)
+}
+
+func truncate(s string, n int) string {
+	if len(s) <= n {
+		return s
+	}
+	return s[:n-3] + "..."
+}
+
+func humanSize(bytes int64) string {
+	const unit = 1024
+	if bytes < unit {
+		return fmt.Sprintf("%dB", bytes)
+	}
+	div, exp := int64(unit), 0
+	for n := bytes / unit; n >= unit; n /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB", float64(bytes)/float64(div), "KMGTPE"[exp])
+}
+
+func init() {
+	// Ensure we can parse flags even with -count or other test flags
+	flag.CommandLine.Parse([]string{})
+}
diff --git a/scripts/extract_wavs.sh b/scripts/extract_wavs.sh
new file mode 100755
index 0000000..454de4d
--- /dev/null
+++ b/scripts/extract_wavs.sh
@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+# Extract all AKAI samples as WAV from all volumes in an AKAI disk image.
+# Usage: ./extract_wavs.sh <iso-file> [output-dir]
+# Uses a single akaiutil session to avoid repeated disk rescans.
+
+set -euo pipefail
+
+AKAIUTIL="${AKAIUTIL:-akaiutil}"
+ISO="${1:?Usage: $0 <iso-file> [output-dir]}"
+OUTPUT="${2:-wavs}"
+
+# Derive ISO basename without extension, sanitized for filesystem use
+isobase=$(basename "$ISO")
+isobase="${isobase%.*}"
+isobase=$(echo "$isobase" | sed 's/ /_/g' | sed 's/[^A-Za-z0-9_.-]/_/g' | sed 's/__*/_/g' | sed 's/^[_.]//; s/[_.]$//')
+OUTPUT="$OUTPUT/$isobase"
+
+TMPFILE=$(mktemp /tmp/akai_cmds.XXXXXX)
+trap 'rm -f "$TMPFILE"' EXIT
+
+mkdir -p "$OUTPUT"
+
+# Phase 1: enumerate partitions from df output
+echo "Enumerating partitions and volumes..."
+DF_OUTPUT=$("$AKAIUTIL" -r "$ISO" 2>/dev/null <<< $'df\nq')
+
+# Parse partition letters from the partition table in df output
+PARTITIONS=()
+while IFS= read -r line; do
+  if [[ "$line" =~ ^[[:space:]]+([A-Z])[[:space:]]+ ]]; then
+    PARTITIONS+=("${BASH_REMATCH[1]}")
+  fi
+done <<< "$DF_OUTPUT"
+
+if [[ ${#PARTITIONS[@]} -eq 0 ]]; then
+  echo "No partitions found in ISO. Trying single-partition layout..."
+  PARTITIONS=("A")
+fi
+
+echo "Found partitions: ${PARTITIONS[*]}"
+
+# Scan each partition for volumes
+VOLUME_LIST=$(
+  {
+    for p in "${PARTITIONS[@]}"; do
+      echo "cd /disk0/$p"
+      echo "dir"
+    done
+    echo "q"
+  } | "$AKAIUTIL" -r "$ISO" 2>/dev/null
+)
+
+# Parse partition-letter:volume-name pairs
+VOLUMES=()
+CURRENT_PART=""
+while IFS= read -r line; do
+  for p in "${PARTITIONS[@]}"; do
+    if [[ "$line" == *"/disk0/$p >"* ]]; then
+      CURRENT_PART="$p"
+    fi
+  done
+  if [[ "$line" =~ ^[[:space:]]+[0-9]+[[:space:]]+(.+)[[:space:]]+-[[:space:]]+ ]]; then
+    name="${BASH_REMATCH[1]}"
+    name="${name%%  -*}"
+    name="$(echo "$name" | sed 's/  *$//')"
+    if [[ -n "$CURRENT_PART" && -n "$name" ]]; then
+      VOLUMES+=("$CURRENT_PART|$name")
+    fi
+  fi
+done <<< "$VOLUME_LIST"
+
+echo "Found ${#VOLUMES[@]} volumes"
+
+# Phase 2: build command file and create output dirs
+> "$TMPFILE"
+
+for entry in "${VOLUMES[@]}"; do
+  IFS='|' read -r part vol_name <<< "$entry"
+
+  safe_name=$(echo "$vol_name" | sed 's/ /_/g' | sed 's/[^A-Za-z0-9_.-]/_/g' | sed 's/__*/_/g' | sed 's/^[_.]//; s/[_.]$//')
+  [[ -z "$safe_name" ]] && safe_name="volume"
+
+  vol_dir="$OUTPUT/$safe_name"
+  mkdir -p "$vol_dir"
+
+  nav_name="${vol_name// /_}"
+  echo "lcd $vol_dir" >> "$TMPFILE"
+  echo "cd /disk0/$part/$nav_name" >> "$TMPFILE"
+  echo "sample2wavall" >> "$TMPFILE"
+done
+
+echo "lcd /" >> "$TMPFILE"
+echo "q" >> "$TMPFILE"
+
+# Phase 3: run extraction
+echo "Starting extraction..."
+START=$SECONDS
+"$AKAIUTIL" -r "$ISO" < "$TMPFILE" 2>/dev/null > /tmp/akai_output.txt
+DURATION=$((SECONDS - START))
+
+total=0
+while IFS= read -r line; do
+  if [[ "$line" =~ exported[[:space:]]+([0-9]+)[[:space:]]+file ]]; then
+    count="${BASH_REMATCH[1]}"
+    total=$((total + count))
+    echo "  -> $count WAVs"
+  fi
+done < /tmp/akai_output.txt
+
+echo ""
+echo "--- Done in ${DURATION}s ---"
+echo "Total WAV files: $total"
+
+echo ""
+echo "WAVs are in: $OUTPUT/"
diff --git a/third_party/akaiutil/Makefile b/third_party/akaiutil/Makefile
new file mode 100755
index 0000000..3ed2f4a
--- /dev/null
+++ b/third_party/akaiutil/Makefile
@@ -0,0 +1,76 @@
+# Copyright (c) 2008-2022 Klaus Michael Indlekofer. All rights reserved.
+#
+# m.indlekofer@gmx.de
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+
+
+VERSION	=	4.6.7
+
+
+
+CFLAGS	+=	-Wall -Wextra -O2
+ifdef FILE_OFFSET_BITS_64
+CFLAGS	+=	-D_FILE_OFFSET_BITS=64
+endif
+
+
+
+all:	akaiutil
+
+install:
+	$(INSTALL_PROGRAM) akaiutil $(PREFIX)/bin/
+
+clean:
+	rm -f akaiutil akaiutil.exe *.o *.obj
+
+back:
+	mkdir -p akaiutil-$(VERSION);\
+	cp -p Makefile Makefile.nmake README.txt gpl*.txt *.c *.h *.vcproj *.sln *.dsw *.dsp akaiutil-$(VERSION);\
+	tar -clvpzf akaiutil-$(VERSION).tar.gz akaiutil-$(VERSION)
+
+
+
+akaiutil:	akaiutil_main.o akaiutil_tar.o akaiutil_file.o akaiutil_take.o akaiutil_wav.o akaiutil.o akaiutil_io.o commonlib.o
+	$(CC) $(CFLAGS) -o $@ akaiutil_main.o akaiutil_tar.o akaiutil_file.o akaiutil_take.o akaiutil_wav.o akaiutil.o akaiutil_io.o commonlib.o -lm
+
+akaiutil_main.o:	akaiutil_main.c akaiutil.h akaiutil_io.h akaiutil_tar.h akaiutil_file.h akaiutil_take.h commoninclude.h
+	$(CC) $(CFLAGS) -c akaiutil_main.c
+
+akaiutil_tar.o:	akaiutil_tar.c akaiutil_tar.h akaiutil_file.h akaiutil_take.h akaiutil.h akaiutil_io.h commoninclude.h
+	$(CC) $(CFLAGS) -c akaiutil_tar.c
+
+akaiutil_file.o:	akaiutil_file.c akaiutil_file.h akaiutil_wav.h akaiutil.h commoninclude.h
+	$(CC) $(CFLAGS) -c akaiutil_file.c
+
+akaiutil_take.o:	akaiutil_take.c akaiutil_take.h akaiutil_wav.h akaiutil.h akaiutil_io.h commoninclude.h
+	$(CC) $(CFLAGS) -c akaiutil_take.c
+
+akaiutil_wav.o:	akaiutil_wav.c akaiutil_wav.h commoninclude.h
+	$(CC) $(CFLAGS) -c akaiutil_wav.c
+
+akaiutil.o:	akaiutil.c akaiutil.h akaiutil_io.h akaiutil_file.h commoninclude.h
+	$(CC) $(CFLAGS) -c akaiutil.c
+
+akaiutil_io.o:	akaiutil_io.c akaiutil_io.h commoninclude.h
+	$(CC) $(CFLAGS) -c akaiutil_io.c
+
+commonlib.o:	commonlib.c commoninclude.h
+	$(CC) $(CFLAGS) -c commonlib.c
+
+
+
+# EOF
diff --git a/third_party/akaiutil/Makefile.nmake b/third_party/akaiutil/Makefile.nmake
new file mode 100755
index 0000000..56910bf
--- /dev/null
+++ b/third_party/akaiutil/Makefile.nmake
@@ -0,0 +1,63 @@
+# Copyright (c) 2008-2021 Klaus Michael Indlekofer. All rights reserved.
+#
+# m.indlekofer@gmx.de
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+
+
+CFLAGS	=	$(CFLAGS) /nologo /O2 /D_VISUALCPP /D_CRT_SECURE_NO_DEPRECATE
+
+LIBS		=	$(LIBS) Winmm.lib
+
+
+
+all:	akaiutil.exe
+
+clean:
+	del /q /f akaiutil.exe *.obj
+
+
+
+akaiutil.exe:	akaiutil_main.obj akaiutil_tar.obj akaiutil_file.obj akaiutil_take.obj akaiutil_wav.obj akaiutil.obj akaiutil_io.obj commonlib.obj
+	$(CC) $(CFLAGS) /Fe$@ akaiutil_main.obj akaiutil_tar.obj akaiutil_file.obj akaiutil_take.obj akaiutil_wav.obj akaiutil.obj akaiutil_io.obj commonlib.obj $(LIBS)
+
+akaiutil_main.obj:	akaiutil_main.c akaiutil.h akaiutil_io.h akaiutil_tar.h akaiutil_file.h akaiutil_take.h commoninclude.h
+	$(CC) $(CFLAGS) /c akaiutil_main.c
+
+akaiutil_tar.obj:	akaiutil_tar.c akaiutil_tar.h akaiutil_file.h akaiutil_take.h akaiutil.h akaiutil_io.h commoninclude.h
+	$(CC) $(CFLAGS) /c akaiutil_tar.c
+
+akaiutil_file.obj:	akaiutil_file.c akaiutil_file.h akaiutil_wav.h akaiutil.h commoninclude.h
+	$(CC) $(CFLAGS) /c akaiutil_file.c
+
+akaiutil_take.obj:	akaiutil_take.c akaiutil_take.h akaiutil_wav.h akaiutil.h akaiutil_io.h commoninclude.h
+	$(CC) $(CFLAGS) /c akaiutil_take.c
+
+akaiutil_wav.obj:	akaiutil_wav.c akaiutil_wav.h commoninclude.h
+	$(CC) $(CFLAGS) /c akaiutil_wav.c
+
+akaiutil.obj:	akaiutil.c akaiutil.h akaiutil_io.h akaiutil_file.h commoninclude.h
+	$(CC) $(CFLAGS) /c akaiutil.c
+
+akaiutil_io.obj:	akaiutil_io.c akaiutil_io.h commoninclude.h
+	$(CC) $(CFLAGS) /c akaiutil_io.c
+
+commonlib.obj:	commonlib.c commoninclude.h
+	$(CC) $(CFLAGS) /c commonlib.c
+
+
+
+# EOF
diff --git a/third_party/akaiutil/README.txt b/third_party/akaiutil/README.txt
new file mode 100755
index 0000000..360c4ec
--- /dev/null
+++ b/third_party/akaiutil/README.txt
@@ -0,0 +1,755 @@
+akaiutil: access to AKAI S900/S1000/S3000 filesystems
+Copyright (c) 2008-2022 by Klaus Michael Indlekofer. All rights reserved.
+Note: Special restrictions apply. See disclaimers below and within the distribution.
+
+Release akaiutil-4.6.7 (21-OCT-2022)
+
+
+
+Email: m.indlekofer@gmx.de
+
+
+
+Usage:
+------
+
+akaiutil [-h] [-r] [-F] [-C] [-l <lock-file>] [-o <start-offset>] [-s <pseudo-disk-size>] [-n <pseudo-disk-number>] [-c <cdrom-index> ...] [-p <physdrive-index> ...] [[-f] <floppy-drive> ...] [[-f] <disk-file> ...]
+	-h	print this info
+	-r	read-only mode
+	-F	disable floppy filesystem for disk-files/CD-ROM drives/physical drives
+	-C	disable cache
+	-l	lock-file
+	-o	set start offset for disk-file/drive in bytes
+	-s	set pseudo-disk size in KB
+	-n	set max. number of pseudo-disks per disk-file/drive
+	-c	CD-ROM drive
+	-p	physical drive
+	-f	floppy drive or disk-file
+		<floppy-drive> = floppyla: | floppylb: | floppyha: | floppyhb:
+
+
+
+Commands:
+---------
+
+help [<cmd>]			print help information for a command
+=man
+
+exit				exit program
+=quit
+=bye
+=q
+
+restart				restart program (with opened disks)
+
+restartkeep			restart program (with opened disks, keep current directory path etc.)
+=restart.
+=sync
+
+df				print disk info
+
+dinfo				print current directory info
+=pwd
+
+cd [<path>]			change current directory
+
+cdi <volume-index>		change current volume
+
+dir [<path>]			list directory
+=ls
+
+dirrec				list current directory recursively
+=lsrec
+
+lstags				list tags in partition
+=dirtags
+
+inittags			initialize tags of disk or partition
+
+rentag <tag-index> <tag-name>	rename tag in partition
+
+cdinfo				print CD3000 CD-ROM info
+
+vcdinfo				print verbose CD3000 CD-ROM info
+
+setcdinfo [<cdlabel>]		set CD3000 CD-ROM info of disk or partition
+
+lcd <dir-path>			change current local (external) directory
+
+ldir				list files in current local (external) directory
+=lls
+
+lsfat				print FAT of current partition
+
+lsfati <file-index>		print FAT-chain of file
+
+lstfati <take-index>		print FAT-chain of DD take
+
+infoi <file-index>		print information for file
+
+infoall				print information for all files in current volume
+
+tinfoi <take-index>		print information for DD take
+
+tinfoall			print information for all DD takes in current partition
+
+del <file-path>			delete file
+=rm
+
+deli <file-index>		delete file
+rmi
+
+tdeli <take-index>		delete DD take
+trmi
+
+ren <old-file-path> <new-file-path> [<new-file-index>]		rename/move file
+=mv
+
+reni <old-file-index> <new-file-path> [<new-file-index>]	rename/move file
+=mvi
+
+setosveri <file-index> <new-os-version>				set OS version of file in S1000/S3000 volume
+
+setosverall <new-os-version>					set OS version of all files in current S1000/S3000 volume
+
+setuncompri <file-index> <new-uncompr>				set uncompr value of compressed file in S900 volume
+
+updateuncompri <file-index>					update uncompr value of compressed file in S900 volume
+
+updateuncomprall						update uncompr value of all compressed files in current S900 volume
+
+sample900uncompr <file-path> [<dest-vol-path>]			uncompress S900 compressed sample file
+=s9uncompr
+
+sample900uncompri <file-index> [<dest-vol-path>]		uncompress S900 compressed sample file
+=s9uncompri
+
+sample900uncomprall [<dest-vol-path>]				uncompress all S900 compressed sample files in current volume
+=s9uncomprall
+
+sample900compr <file-path> [<dest-vol-path>]			compress S900 non-compressed sample file
+=s9compr
+
+sample900compri <file-index> [<dest-vol-path>]			compress S900 non-compressed sample file
+=s9compri
+
+sample900comprall [<dest-vol-path>]				compress all S900 non-compressed sample files in current volume
+=s9comprall
+
+fixramname <file-path>						fix name in file header
+
+fixramnamei <file-index>					fix name in file header
+
+fixramnameall							fix name in file header of all files in current volume
+
+clrtagi <file-index> {<tag-index>|all}				untag file
+
+clrtagall {<tag-index>|all}					untag all files in current volume
+
+settagi <file-index> <tag-index>				tag file
+
+settagall <tag-index>						tag all files in current volume
+
+treni <take-index> <new-name>					rename DD take
+=tmvi
+
+clrfiltertag {<tag-index>|all}					remove tag from file filter
+
+setfiltertag <tag-index>					add tag to file filter
+
+copy <src-file-path> <new-file-path> [<new-file-index>]		copy file
+=cp
+
+copyi <src-file-index> <new-file-path> [<new-file-index>]	copy file
+=cpi
+
+copyvol <src-volume-path> <new-volume-path>			copy volume (with all of its files)
+=cpvol
+
+copyvoli <src-volume-index> <new-volume-path>			copy volume (with all of its files)
+=cpvoli
+
+copypart <src-partition-path> <dst-partition-path>		copy all volumes of a partition
+=cppart
+
+copytags <src-partition-path> <dst-partition-path>		copy all tags of a partition
+=cptags
+
+wipevol <volume-path>				delete all files in volume
+=wipedir
+=rmall
+
+wipevoli <volume-index>				delete all files in volume
+=wipediri
+=rmalli
+
+delvol <volume-path>				delete volume and all of its files
+=deldir
+=rmvol
+=rmdir
+
+delvoli <volume-index>				delete volume and all of its files
+=deldiri
+=rmvoli
+=rmdiri
+
+formatfloppyl9						format/erase low-density floppy for S900/S950, create filesystem
+=formatfl9
+
+formatfloppyl1						format/erase low-density floppy for S1000, create filesystem
+=formatfl1
+
+formatfloppyl3						format/erase low-density floppy for S3000, create filesystem
+=formatfl3
+
+formatfloppyh9						format/erase high-density floppy for S950, create filesystem
+=formatfh9
+
+formatfloppyh1						format/erase high-density floppy for S1000, create filesystem
+=formatfh1
+
+formatfloppyh3						format/erase high-density floppy for S3000, create filesystem
+=formatfh3
+
+wipefloppy						create filesystem on floppy
+=newfsfloppy
+
+formatharddisk9 [<total-size>[M]|SH205|SUPRA20M|SUPRA30M|SUPRA60M]	create filesystem on harddisk for S900/S950 (size in blocks or MB, or drive name)
+=formathd9
+=newfsharddisk9
+=newfshd9
+
+formatharddisk1 [<part-size>[M] [<total-size>[M]]]	create filesystem on harddisk for S1000 (size in blocks or MB)
+=formathd1
+=newfsharddisk9
+=newfshd1
+
+formatharddisk3 [<part-size>[M] [<total-size>[M]]]	create filesystem on harddisk for S3000 or CD3000 (size in blocks or MB)
+=formathd3
+=newfsharddisk3
+=newfshd3
+
+formatharddisk3cd [<part-size>[M] [<total-size>[M]]]	create filesystem on harddisk for CD3000 CD-ROM (size in blocks or MB)
+=formatcd
+=newfsharddisk3cd
+=newfscd
+
+wipepart [<partition-path>]				create filesystem in harddisk partition
+=newfspart
+
+wipepart3cd [<partition-path>]				create filesystem in harddisk partition for CD3000 CD-ROM
+=newfspart3cd
+
+fixpart [<partition-path>]			fix filesystem in harddisk partition
+
+fixharddisk [<disk-path>]			fix filesystem on harddisk
+
+scanbadblkspart [<partition-path>]		scan for bad blocks/clusters in partition
+
+markbadblkspart [<partition-path>]		mark free bad blocks/clusters in partition
+
+scanbadblksdisk [<disk-path>]			scan for bad blocks/clusters in all partitions of disk
+
+markbadblksdisk [<disk-path>]			mark free bad blocks/clusters in all partitions of disk
+
+getdisk <file-name>				get disk (to external file)
+=dget
+=dexport
+
+putdisk <file-name>				put disk (from external file)
+=dput
+=dimport
+
+getpart [<partition-path>] <file-name>		get partition (to external file)
+=pget
+=pexport
+
+putpart <file-name> [<partition-path>]		put partition (from external file)
+=pput
+=pimport
+
+gettags <file-name>				get tags from partition (to external file)
+=tagsget
+=tagsexport
+
+puttags <file-name>				put tags to partition (from external file)
+=tagsput
+=tagsimport
+
+renvol <old-path> <new-name>			rename volume
+=rendir
+=mvvol
+=mvdir
+
+renvoli <volume-index> <new-name>		rename volume
+=rendiri
+=mvvoli
+=mvdiri
+
+setosvervol <new-os-version>				set OS version of current volume
+
+setosvervoli <volume-index> <new-os-version>		set OS version of volume
+
+setlnum <new-load-number>				set load number of current volume (OFF for none)
+
+setlnumi <volume-index> <new-load-number>		set load number of volume (OFF for none)
+
+lsparam							list parameters in current volume
+
+lsparami <volume-index>					list parameters in volume
+
+initparam						initialize parameters in current volume
+
+initparami <volume-index>				initialize parameters in volume
+
+setparam <par-index> <par-value>			set parameters in current volume
+
+setparami <volume-index> <par-index> <par-value>	set parameters in volume
+
+getparam <file-name>					get parameters from current volume (to external file)
+=paramget
+=paramexport
+
+getparami <volume-index> <file-name>			get parameters from volume (to external file)
+=paramgeti
+=paramexporti
+
+putparam <file-name>					put parameters to current volume (from external file)
+=paramput
+=paramimport
+
+putparami <volume-index> <file-name>			put parameters to volume (from external file)
+=paramputi
+=paramimporti
+
+get <file-path> [<begin-byte> [<end-byte>]]	get file (to external)
+=export
+
+geti <file-index> [<begin-byte> [<end-byte>]]	get file (to external)
+=exporti
+
+getall						get all files (to external)
+=exportall
+
+sample2wav <file-path>				convert sample file into external WAV file
+=s2wav
+=getwav
+
+sample2wavi <file-index>			convert sample file into external WAV file
+=s2wavi
+=getwavi
+
+sample2wavall					convert all sample files into external WAV files
+=s2wavall
+=getwavall
+
+put [<volume-path>/]<file-name> [<file-index>]			put file (from external, use * for all local files)
+=import
+
+wav2sample [<volume-path>/]<wav-file> [<file-index>]		convert external WAV file into sample file (use *.wav for all local WAV files)
+=wav2s
+=putwav
+
+wav2sample9 [<volume-path>/]<wav-file> [<file-index>]		convert external WAV file into S900 non-compressed sample file (use *.wav for all local WAV files)
+=wav2s9
+=putwav9
+
+wav2sample9c [<volume-path>/]<wav-file> [<file-index>]		convert external WAV file into S900 compressed sample file (use *.wav for all local WAV files)
+=wav2s9c
+=putwav9c
+
+wav2sample1 [<volume-path>/]<wav-file> [<file-index>]		convert external WAV file into S1000 sample file (use *.wav for all local WAV files)
+=wav2s1
+=putwav1
+
+wav2sample3 [<volume-path>/]<wav-file> [<file-index>]		convert external WAV file into S3000 sample file (use *.wav for all local WAV files)
+=wav2s3
+=putwav3
+
+tgeti <take-index>				get DD take (to external)
+=texporti
+
+tgetall						get all DD takes (to external)
+=texportall
+
+take2wavi <take-index>				convert DD take into external WAV file
+=t2wavi
+=tgetwavi
+=getwavti
+
+take2wavall					convert all DD takes into external WAV files
+=t2wavall
+=tgetwavall
+=getwavtall
+
+tput <take-file>				put DD take (from external, use *.TK for all local DD take files)
+=timport
+
+wav2take <wav-file>				convert external WAV file into DD take (use *.wav for all local WAV files)
+=wav2t
+=tputwav
+=putwavt
+
+tarc <tar-file>		tar c from current directory (to external)
+=target
+=gettar
+
+tarcwav <tar-file>	tar c from current directory (to external) with WAV conversion
+=targetwav
+=gettarwav
+
+tarx <tar-file>		tar x in current directory (from external)
+=tarput
+=puttar
+
+tarx9 <tar-file>	tar x in current directory (from external) for S900
+=tarput9
+=puttar9
+
+tarx1 <tar-file>	tar x in current directory (from external) for S1000
+=tarput1
+=puttar1
+
+tarx3 <tar-file>	tar x in current directory (from external) for S3000 or CD3000
+=tarput3
+=puttar3
+
+tarx3cd <tar-file>	tar x in current directory (from external) for CD3000 CD-ROM
+=tarput3cd
+=puttar3cd
+
+tarxwav <tar-file>	tar x in current directory (from external) with WAV conversion
+=tarputwav
+=puttarwav
+
+tarxwav9 <tar-file>	tar x in current directory (from external) with WAV conversion to S900 non-compressed sample
+=tarputwav9
+=puttarwav9
+
+tarxwav9c <tar-file>	tar x in current directory (from external) with WAV conversion to S900 compressed sample
+=tarputwav9c
+=puttarwav9c
+
+tarxwav1 <tar-file>	tar x in current directory (from external) with WAV conversion to S1000 sample
+=tarputwav1
+=puttarwav1
+
+tarxwav3 <tar-file>	tar x in current directory (from external) with WAV conversion to S3000 sample
+=tarputwav3
+=puttarwav3
+
+mkvol [<volume-path>]						create new volume
+=mkdir
+
+mkvol9 [<volume-path>]						create new volume for S900
+=mkdir9
+
+mkvol1 [<volume-path> [<load-number>]]				create new volume for S1000
+=mkdir1
+
+mkvol3 [<volume-path> [<load-number>]]				create new volume for S3000 or CD3000
+=mkdir3
+
+mkvol3cd [<volume-path> [<load-number>]]			create new volume for CD3000 CD-ROM
+=mkdir3cd
+
+mkvoli <volume-index> [<volume-name> [<load-number>]]		create new volume at index
+=mkdiri
+
+mkvoli9 <volume-index> [<volume-name>]				create new volume for S900 at index
+=mkdiri9
+
+mkvoli1 <volume-index> [<volume-name> [<load-number>]]		create new volume for S1000 at index
+=mkdiri1
+
+mkvoli3 <volume-index> [<volume-name> [<load-number>]]		create new volume for S3000 or CD3000 at index
+=mkdiri3
+
+mkvoli3cd <volume-index> [<volume-name> [<load-number>]]	create new volume for CD3000 CD-ROM
+=mkdiri3cd
+
+dircache		print cache information
+=lscache
+
+disablecache		disable cache
+
+enablecache		enable cache
+
+lock			acquire lock
+
+unlock			release lock
+
+playwav [<wav-file>]	start playback of current external WAV file
+=p
+
+stopwav			stop playback of current external WAV file
+=s
+
+delwav			delete current external WAV file
+=rmwav
+
+
+
+Examples:
+---------
+
+Example 1: access floppy image fff.img
+akaiutil.exe fff.img
+
+Example 2: access harddisk images hhh1.img and hhh2.img
+akaiutil.exe hhh1.img hhh2.img
+
+Example 3: access harddisk image hhh.img and floppy image fff.img
+akaiutil.exe hhh.img fff.img
+
+Example 4: access multi-harddisk image mmm.img with pseudo-disks of 524280KB
+akaiutil.exe -s 524280 mmm.img
+
+Example 5: access high-density (HD) floppy in floppy drive A: on Windows PC:
+akaiutil.exe floppyha:
+
+Example 6: access Windows physical drive 1 and Windows CD-ROM drive 0
+akaiutil.exe -p 1 -c 0
+
+Example 7: access Windows physical drive 2, harddisk image hhh.img, and floppy image fff.img
+akaiutil.exe -p 2 hhh.img fff.img
+
+Example 8: access UNIX harddisks /dev/da1, /dev/da2, and harddisk image hhh.img
+akaiutil /dev/da1 /dev/da2 hhh.img
+
+Example 9: access Darwin harddisk /dev/disk1
+akaiutil /dev/disk1
+
+Example 10: access Darwin CD-ROM /dev/disk2s0 in read-only mode
+akaiutil -r /dev/disk2s0
+
+
+
+Warning:
+--------
+
+Accessing disk-files or floppies or physical drives might destroy their contents!!! Use at your own risk!!!
+It is strongly recommended to use the read-only mode (-r) for testing and for accessing valuable drives, floppies, or files.
+
+
+
+Notes:
+------
+
+* whole (pseudo-)disks can be imported/exported via "putdisk"/"getdisk"
+* whole partitions can be imported/exported via "putpart"/"getpart"
+* individual files can be imported/exported via "put"/"get"
+* sample files can be exported to external WAV files via "sample2wav", "sample2wavall"
+* DD takes can be exported to external WAV files via "take2wav", "take2wavall"
+* external WAV files can be imported to sample files via "wav2sample", "wav2sample9", "wav2sample1","wav2sample3"
+  WAV files for sample import must be mono or stereo, and in 8bit or 16bit or 24bit or 32bit PCM format
+* external WAV files can be imported to DD takes via "wav2take"
+  WAV files for DD take import must be mono or stereo, and in 8bit or 16bit or 24bit or 32bit PCM format
+* the current external WAV file (e.g. previously exported via "sample2wav" or "take2wav") can be played back via "playwav"
+* individual files can be copied via "copy"
+* whole volumes and partitions can be copied via "copyvol" and "copypart"
+* whole directory trees can be imported/exported from/to tar archives via "tarput"/"target"
+* WAV file conversion for tar archives via "tarputwav"/"targetwav"
+* file path names in akaiutil are of the form "/disk/partition/volume/file", e.g. "/disk2/C/VOLUME_007/SINE.S"
+* for access to files/volumes via index, some commands have an "i" version
+* abbreviations:
+  ".." = one level up, "." = stay in same directory
+  "/N" = "/diskN"
+  "/floppyN" = "/diskN/A/<volume1>"
+  '_' can be used as a typable replacement for ' ' (space) in file or volume names
+* if the pseudo-disk size ("-s" option) and the max. number of pseudo-disks ("-n" option) are both specified,
+  the given values are taken and the usable disk size is not determined automatically,
+  which might be useful e.g. for accessing harddisks which have bad blocks
+* for shared access to drives or disk-files,
+  it might be useful to disable the cache (via the "-C" option or via the "disablecache" command),
+  and the "restartkeep" command can be used to rescan disks/partitions/volumes,
+  and a lock-file ("-l" option and "lock"/"unlock" commands) can be used for exclusive access
+* for detailed information about individual akaiutil commands please read the online help infos
+
+
+
+Floppy drives:
+--------------
+
+In order to access a floppy drive to format, read, or write an AKAI floppy on a Windows PC,
+fdrawcmd.sys (by Simon Owen, see https://simonowen.com/fdrawcmd/) has to be installed.
+
+Floppy drive arguments for akaiutil running on a Windows PC:
+  "floppyla:" for low-density (DD) floppy in drive A:
+  "floppylb:" for low-density (DD) floppy in drive B:
+  "floppyha:" for high-density (HD) floppy in drive A:
+  "floppyhb:" for high-density (HD) floppy in drive B:
+
+
+
+Formatting drives and images:
+-----------------------------
+
+Low-density (DD) floppy size: 800 blocks (1KB) = 800KB
+
+High-density (HD) floppy size: 1600 blocks (1KB) = 1600KB
+
+Max. S900/S950 harddisk (or CD-ROM) size: 8191 blocks (8KB) = 65528KB = approx. 64MB
+
+S900/S950 standard harddisk sizes:
+2601 blocks (8KB) = 20808KB ("Atari SH205")
+2500 blocks (8KB) = 20000KB ("Supra 20M")
+3812 blocks (8KB) = 30496KB ("Supra 30M")
+7624 blocks (8KB) = 60992KB ("Supra 60M")
+
+Max. S1000/S3000 harddisk (or CD-ROM) size: 65535 blocks (8KB) = 524280KB = approx. 512MB
+
+S1000/S3000 standard harddisk partition sizes:
+3840 blocks (8KB) = 30720KB = 30MB
+5120 blocks (8KB) = 40960KB = 40MB
+6400 blocks (8KB) = 51200KB = 50MB
+7680 blocks (8KB) = 61440KB = 60MB
+
+ZIP100 disk size (as seen by akaiutil): 12288 blocks (8KB) = 98304KB = 96MB
+
+ZIP250 disk size (as seen by akaiutil): 30595 blocks (8KB) = 244760KB = approx. 239MB
+
+Warning: Formatting disk-files or floppies or physical drives destroys their contents!!! Use at your own risk!!!
+
+Example 1: format S900 low-density (DD) floppy in floppy drive A: on Windows PC:
+akaiutil.exe floppyla:
+-> formatfloppyl9
+
+Example 2: create and format S900 low-density floppy image
+dd if=/dev/zero of=fff.img bs=1024 count=800
+akaiutil fff.img
+-> formatfloppyl9
+
+Example 3: create and format S1000 high-density floppy image
+dd if=/dev/zero of=fff.img bs=1024 count=1600
+akaiutil fff.img
+-> formatfloppyh1
+
+Example 4: create and format CD3000 CD-ROM image of max. size
+dd if=/dev/zero of=hhh.img bs=8192 count=65535
+akaiutil hhh.img
+-> formatharddisk3cd 60M
+(this gives 8 partitions of 60MB and 1 partition of approx. 32MB)
+-> setcdinfo MYCDROM
+(this must be done after all volumes/files have been transferred)
+
+Example 5: create and format S950 harddisk image of max. size
+dd if=/dev/zero of=hhh.img bs=8192 count=8191
+akaiutil hhh.img
+-> formatharddisk9
+
+Example 6: format ZIP100 drive at Windows physical drive 3 for S1000
+akaiutil.exe -p 3
+-> formatharddisk1 60M
+(this gives 1 partition of 60MB and 1 partition of 36MB)
+
+Example 7: format drive at Windows physical drive 4 for S1100 with DD space
+akaiutil.exe -p 4
+-> formatharddisk1 1M 1M
+(this gives 1 partition of 1MB, rest of disk is allocated for DD)
+
+
+
+Compilation:
+------------
+
+Depending on the operating system and the programming environment,
+use Makefile (for make) or Makefile.nmake (for nmake) or the .vcproj file.
+
+
+
+References:
+-----------
+
+* documentation, manuals, and webpages for AKAI samplers
+* floppies, harddisks, CD-ROMs, and files for AKAI samplers
+* "AkaiDisk" and its documentation, by Paul Kellett, accessed 09-JAN-2008, 06-MAR-2008, 27-MAR-2010
+* "akaitools", by Hiroyuki Ohsaki, accessed 09-JAN-2008
+* "akaifs", by Raymond Dresens and Roger Karis, accessed 18-JAN-2008
+* "libakai", by Sébastien Métrot and Christian Schoenebeck, accessed 09-JAN-2008
+* "fdrawcmd.sys" by Simon Owen, https://simonowen.com/fdrawcmd/, accessed 14-AUG-2020
+* "DiskUtil" by Simon Owen, https://simonowen.com/fdrawcmd/DiskUtil.zip, accessed 14-AUG-2020
+
+
+
+---
+The following holds for all files in this distribution (unless stated otherwise on an
+individual basis for each file and statement):
+
+These program/data/document/HTML/picture/media files (materials) are distributed in the
+hope that they will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. In no event shall the author be
+liable for any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitue goods or services; loss of use,
+data, or profits; or business interruption) however caused and on any theory of liability,
+whether in contract, strict liability, or tort (including negligence or otherwise) arising
+in any way out of the use of data/information/software from this distribution, even if
+advised of the possibility of such damage. 
+
+The contents of this distribution are intended for educational, non-commercial purposes
+only. Materials contained herein are property of their respective owners.
+All brand names and trademarks are property of their respective owners.
+If any copyrighted works/trademarks have been used, please contact the author
+and the item will be either removed or properly credited (at the copyright/trademark
+owner's discretion). We have no intention of violating any copyrights or trademarks.
+This distribution might use inlining and deep-linking, i.e. links in this distribution
+might lead directly to materials on other web sites/distributions (in which case the
+target page normally should be listed/credited in a "links" section). The author does
+not take responsibility for the contents of any links referred to. We do not necessarily 
+endorse, sanction, support, encourage, verify or agree with the contents, opinions or
+statements of/on any of the linked pages. These statements hold for all links/references
+in all files in this distribution. We are in no way affiliated with any
+companies/institutions/individuals which might be mentioned in any manner in this
+distribution.
+
+The author does not take responsibility for incorrect, incomplete or misleading information.
+Statements are to be considered as the author's free personal opinion. The author does not
+necessarly possess any of the items mentioned in files in this distribution.
+
+Files (and the information therein) created by the author are copyright
+(c) by the author. Unless protected/restricted otherwise, the author permits
+reproduction/redistribution of material contained in this distribution under the condition
+that the item is properly credited. Links to items/materials in this distribution are welcome.
+Projects/publications/papers that make use of materials, programs, or generated output
+of this distribution must properly credit the author and mention the usage of this distribution.
+Please contact the author for comments or further questions
+and permission to use materials/information from this distribution.
+
+
+
+---
+This product includes software developed by the University of California, Berkeley
+and its contributors.
+
+Copyright (c) 1987-2002 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. [rescinded 22 July 1999]
+4. Neither the name of the University nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+
+
+---
+End of file
diff --git a/third_party/akaiutil/akaiutil.c b/third_party/akaiutil/akaiutil.c
new file mode 100755
index 0000000..7878c0e
--- /dev/null
+++ b/third_party/akaiutil/akaiutil.c
@@ -0,0 +1,7254 @@
+/*
+* Copyright (C) 2008,2010,2012,2018,2019,2020,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+#include "akaiutil_io.h"
+#include "akaiutil.h"
+#include "akaiutil_file.h"
+#include "akaiutil_take.h"
+
+
+
+/* disks */
+struct disk_s disk[DISK_NUM_MAX]; /* disks, Note: one for each disk, system-wide */
+u_int disk_num; /* number of disks */
+
+/* partitions */
+struct part_s part[PART_NUM_MAX]; /* partitions, Note: one for each partition, system-wide */
+u_int part_num; /* number of partitions */
+
+/* current directory */
+struct disk_s *curdiskp; /* current disk pointer into disk[], NULL if system-level */
+						 /* Note: unique, fixed mapping to each file */
+struct part_s *curpartp; /* current partition pointer into part[], NULL if disk-level */
+						 /* Note: unique, fixed mapping to each partition */
+struct vol_s *curvolp; /* current volume pointer into curvol_buf, NULL if disk- or partition-level */
+					   /* Note: neither fixed nor unique mapping to each volume!!! */
+struct vol_s curvol_buf; /* current volume buffer, Note: only one buffer, might change volume identity!!! */
+
+/* for operations with current directory, Note: one instance only, not recursive!!! */
+struct disk_s *savecurdiskp;
+struct part_s *savecurpartp;
+struct vol_s *savecurvolp;
+struct vol_s savecurvol_buf;
+int savecurvolmodflag; /* modifier flag */
+char savecurvolname[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+u_int savecurvolindex;
+
+char dirnamebuf[DIRNAMEBUF_LEN+1]; /* +1 for '\0' */
+
+/* filter tags */
+u_char curfiltertag[AKAI_FILE_TAGNUM];
+
+
+
+int
+open_disk(char *name,int readonly,OFF64_T startoff,u_int pseudodisksize,u_int pseudodisknum)
+{
+	int fd;
+#ifdef _VISUALCPP
+	int fldrn;
+	int fldrtype;
+#endif /* _VISUALCPP */
+	u_int disksize;
+	u_int i;
+
+	if (name==NULL){
+		return -1;
+	}
+	if (disk_num>=DISK_NUM_MAX){
+		return -1;
+	}
+
+	/* Note: pseudodisksize>AKAI_DISKSIZE_MAX is allowed */
+	/* Note: pseudodisksize==0 is allowed and means: pseudo-disk size is not specified */
+
+	if (pseudodisknum>PSEUDODISK_NUM_MAX){
+		pseudodisknum=PSEUDODISK_NUM_MAX; /* limit */
+	}
+	/* Note: pseudodisknum==0 is allowed and means: max. number of pseudo-disks is not specified */
+
+	fd=-1;
+
+#ifdef _VISUALCPP
+	fldrn=-1;
+	fldrtype=FLDR_TYPE_FLH; /* XXX */
+	/* check if name corresponds to floppy drive */
+	if (strcasecmp(name,"floppyla:")==0){
+		fldrn=0;
+		fldrtype=FLDR_TYPE_FLL;
+	}else if (strcasecmp(name,"floppylb:")==0){
+		fldrn=1;
+		fldrtype=FLDR_TYPE_FLL;
+	}else if (strcasecmp(name,"floppyha:")==0){
+		fldrn=0;
+		fldrtype=FLDR_TYPE_FLH;
+	}else if (strcasecmp(name,"floppyhb:")==0){
+		fldrn=1;
+		fldrtype=FLDR_TYPE_FLH;
+	}
+	if (fldrn>=0){ /* is floppy drive? */
+		/* Note: ignore startoff,pseudodisksize,pseudodisknum if floppy drive */
+		/* Note: fldr_open() does not consider readonly flag */
+		if (fldr_open(fldrn,fldrtype)<0){
+			PRINTF_ERR("disk%u: cannot open \"%s\"\n",disk_num,name);
+			/* discard disk, keep old disk_num */
+			return -1;
+		}
+		PRINTF_OUT("disk%u: \"%s\"\n",disk_num,name);
+
+		disk[disk_num].index=disk_num; /* index */
+		disk[disk_num].fd=-1; /* no file descriptor */
+		disk[disk_num].fldrn=fldrn; /* floppy drive number */
+		disk[disk_num].readonly=readonly;
+		disk[disk_num].startoff=0; /* no start offset (Note: startoff is ignored by io_blks_direct() if floppy drive) */
+		if (fldrtype==FLDR_TYPE_FLH){
+			disk[disk_num].totsize=AKAI_FLH_SIZE*AKAI_FL_BLOCKSIZE; /* disk size in bytes */
+			disk[disk_num].type=DISK_TYPE_FLH;
+		}else{
+			disk[disk_num].totsize=AKAI_FLL_SIZE*AKAI_FL_BLOCKSIZE; /* disk size in bytes */
+			disk[disk_num].type=DISK_TYPE_FLL;
+		}
+		disk[disk_num].blksize=AKAI_FL_BLOCKSIZE; /* blocksize */
+		/* disk size in blocks */
+		disk[disk_num].bsize=disk[disk_num].totsize/disk[disk_num].blksize;
+
+		disk_num++; /* found one */
+
+		return 0;
+	}else{
+		fldrn=-1; /* no floppy drive */
+	}
+#endif /* _VISUALCPP */
+
+	if (readonly){
+		fd=OPEN(name,O_RDONLY|O_BINARY,0);
+	}else{
+		fd=OPEN(name,O_RDWR|O_BINARY,0666);
+	}
+	if (fd<0){
+		PERROR("open");
+		PRINTF_ERR("disk%u: cannot open \"%s\"\n",disk_num,name);
+		/* discard disk, keep old disk_num */
+		return -1;
+	}
+	for (i=0;(disk_num<DISK_NUM_MAX)&&(i<PSEUDODISK_NUM_MAX);){
+		if ((pseudodisksize>0)&&(pseudodisknum>0)){ /* pseudo-disk size and max. number of pseudo-disks given? */
+			/* take given pseudodisksize as usable disk size */
+			/* Note: don't determine usable disk size of current pseudo-disk */
+			/* Note: in particular useful for disk with bad blocks */
+			disksize=pseudodisksize;
+		}else{
+			/* determine usable disk size of current pseudo-disk, use pseudodisksize as upper limit (if >0) */
+			/* Note: possibly not useful for disk with bad blocks */
+			disksize=akai_disksize(fd,startoff,pseudodisksize);
+			if ((i>0)&&(disksize==0)){ /* not first pseudo-disk and empty? */
+				break; /* done */
+			}
+		}
+		if ((pseudodisksize>0)||(pseudodisknum>0)||(startoff>0)){
+			PRINTF_OUT("disk%u: \"%s\" (start: byte 0x%02x%08x)\n",
+				disk_num,
+				name,
+				(u_int)(startoff>>32),
+				(u_int)(0xffffffff&startoff));
+		}else{
+			PRINTF_OUT("disk%u: \"%s\"\n",disk_num,name);
+		}
+		if (disksize>AKAI_DISKSIZE_MAX){
+			disksize=AKAI_DISKSIZE_MAX; /* limit for usable disk size */
+		}
+		if ((pseudodisksize>0)&&(disksize<pseudodisksize)){
+			PRINTF_OUT("disk%u: usable disk size is limited to %u KB\n",disk_num,disksize/1024);
+		}
+
+		disk[disk_num].index=disk_num; /* index */
+		disk[disk_num].fd=fd;
+#ifdef _VISUALCPP
+		disk[disk_num].fldrn=-1; /* no floppy drive */
+#endif /* _VISUALCPP */
+		disk[disk_num].readonly=readonly;
+		disk[disk_num].startoff=startoff; /* start offset in bytes */
+		disk[disk_num].totsize=disksize; /* disk size in bytes */
+		disk[disk_num].type=DISK_TYPE_HD; /* XXX first guess for type */
+		disk[disk_num].blksize=AKAI_HD_BLOCKSIZE; /* XXX first guess for blocksize */
+		/* disk size in blocks */
+		disk[disk_num].bsize=disk[disk_num].totsize/disk[disk_num].blksize;
+
+		disk_num++; /* found one */
+
+		if ((pseudodisksize==0) /* pseudo-disk size not given? */
+			&&((pseudodisknum==0)||(disksize==0))){ /* and: max. number of pseudo-disks not given or usable disk size==0? */
+			break; /* done */
+		}
+
+		/* next pseudo-disk */
+		i++;
+		if ((pseudodisknum>0)&&(i>=pseudodisknum)){ /* max. number of pseudo-disks given and done? */
+			break; /* done */
+		}
+		if (pseudodisksize>0){ /* pseudo-disk size given? */
+			/* increment pseudo-disk start offset by pseudodisksize (which can be larger than the usable disk size) */
+			startoff+=(OFF64_T)pseudodisksize;
+		}else{
+			/* pseudo-disk size is not given */
+			/* increment pseudo-disk start offset by disksize (usable disk size, determined above) */
+			/* Note: now, disksize>0 (see check above) */
+			startoff+=disksize;
+		}
+	}
+
+	return 0;
+}
+
+
+
+void
+close_alldisks(void)
+{
+	int fd;
+#ifdef _VISUALCPP
+	int fldrn;
+#endif /* _VISUALCPP */
+	u_int i;
+
+	while (disk_num>0){
+		disk_num--;
+		fd=disk[disk_num].fd;
+		if (fd>=0){ /* opened? */
+			/* close */
+			CLOSE(disk[disk_num].fd);
+			/* mark all disks with same fd as closed */
+			for (i=0;i<=disk_num;i++){
+				if (disk[i].fd==fd){
+					disk[i].fd=-1; /* closed */
+				}
+			}
+		}
+#ifdef _VISUALCPP
+		fldrn=disk[disk_num].fldrn;
+		if ((fldrn>=0)&&(fldrn<FLDRNUM)&&(fldr_h[fldrn]!=INVALID_HANDLE_VALUE)){ /* floppy drive opened? */
+			/* close */
+			CloseHandle(fldr_h[fldrn]);
+			fldr_h[fldrn]=INVALID_HANDLE_VALUE; /* closed */
+		}
+		disk[disk_num].fldrn=-1; /* no floppy drive */
+#endif /* _VISUALCPP */
+	}
+}
+
+
+
+/* determine usable disk size in bytes */
+/* Note: possibly not useful for disk with bad blocks */
+u_int
+akai_disksize(int fd,OFF64_T startoff,u_int disksizemax)
+{
+	u_int off,siz;
+	static u_char bbuf[AKAI_DISKSIZE_GRAN];
+
+	if (fd<0){
+		return 0;
+	}
+
+	/* Note: disksizemax==0 is allowed and means: max. usable disk size is not specified */
+	if ((disksizemax==0)||(disksizemax>AKAI_DISKSIZE_MAX)){
+		disksizemax=AKAI_DISKSIZE_MAX; /* limit for usable disk size */
+	}
+	/* XXX 32bit overflow protection for off<<=1 below */
+	if (disksizemax>0x80000000){
+		disksizemax=0x80000000;
+	}
+	/* determine start offset >= disksizemax, must be power of 2 */
+	for (off=1;off<disksizemax;off<<=1)
+		;
+	siz=off;
+	for (;;){
+		siz>>=1;
+		/* can read 1 block at off ? */
+		if ((off>=disksizemax) /* beyond max. disk limit? */
+			||(LSEEK64(fd,startoff+((OFF64_T)off),SEEK_SET)<0)
+			||(READ(fd,bbuf,AKAI_DISKSIZE_GRAN)!=(int)AKAI_DISKSIZE_GRAN)){
+			/* block at off is not readable -> off is too high */
+#ifdef DEBUG
+			PRINTF_ERR("akai_disksize: off=%08x siz=%08x high\n",off,siz);
+#endif
+			if (siz<AKAI_DISKSIZE_GRAN){
+				if (off==0){ /* even block at 0 is not readable? */
+					/* no blocks are readable */
+					return 0; /* exit */
+				}
+				off-=AKAI_DISKSIZE_GRAN; /* block at off is not readable */
+				/* Note: must check if block at new off is readable */
+			}else{
+				off-=siz;
+			}
+		}else{
+			/* block at off is readable -> off is OK or too low */
+#ifdef DEBUG
+			PRINTF_ERR("akai_disksize: off=%08x siz=%08x low\n",off,siz);
+#endif
+			if (siz<AKAI_DISKSIZE_GRAN){
+				break; /* end of iteration */
+			}
+			off+=siz;
+		}
+	}
+	/* now, off is at last readable disk block */
+
+	/* return value in bytes */
+	if (off<AKAI_DISKSIZE_MAX){
+		off+=AKAI_DISKSIZE_GRAN; /* !!! */
+	}else{
+		off=AKAI_DISKSIZE_MAX;
+	}
+	if (off>disksizemax){
+		off=disksizemax;
+	}
+#ifdef DEBUG
+	PRINTF_ERR("akai_disksize done: size=%08x (%u)\n",off,off);
+#endif
+	return off;
+}
+
+
+
+int
+akai_io_blks(struct part_s *pp,u_char *buf,u_int bstart,u_int bsize,int cachealloc,int mode)
+{
+
+	if ((pp==NULL)||(pp->diskp==NULL)){
+		return -1;
+	}
+
+	if ((pp->diskp->readonly)&&(mode==IO_BLKS_WRITE)){
+		PRINTF_ERR("disk%u: read-only, cannot write\n",pp->diskp->index);
+		return -1;
+	}
+
+	if (((bstart+bsize)>pp->bsize)
+		||((pp->bstart+bstart+bsize)>pp->diskp->bsize)){
+		PRINTF_ERR("disk%u: cannot %s outside partition/disk\n",
+			pp->diskp->index,
+			(mode==IO_BLKS_WRITE)?"write":"read");
+		return -1;
+	}
+
+	return io_blks(pp->diskp->fd,
+#ifdef _VISUALCPP
+				   pp->diskp->fldrn,
+#endif /* _VISUALCPP */
+				   pp->diskp->startoff,
+				   buf,
+				   pp->bstart+bstart,
+				   bsize,
+				   pp->blksize,
+				   cachealloc,mode);
+}
+
+
+
+/* open external file read-only */
+int
+akai_openreadonly_extfile(char *name)
+{
+	int fd;
+	u_int nlen;
+	char *nbuf;
+	u_int k;
+
+	if (name==NULL){
+		return -1;
+	}
+
+	/* try given name */
+	fd=OPEN(name,O_RDONLY|O_BINARY,0);
+	if (fd>=0){ /* success? */
+		return fd;
+	}
+	/* no success with name */
+
+	/* try again with modified name: ' ' instead of '_' for keyboard entry */
+	nlen=(u_int)strlen(name);
+	if (nlen==0){
+		return -1;
+	}
+	/* Note: use own file name buffer for (possible) modification, don't modify string in name */
+	nbuf=(char *)malloc(nlen+1); /* +1 for '\0' */
+	if (nbuf==NULL){
+		PERROR("malloc");
+		return -1;
+	}
+	for (k=0;k<nlen;k++){
+		if (name[k]=='_'){
+			nbuf[k]=' ';
+		}else{
+			nbuf[k]=name[k];
+		}
+	}
+	nbuf[k]='\0';
+	fd=OPEN(nbuf,O_RDONLY|O_BINARY,0);
+	free(nbuf);
+	return fd;
+}
+
+
+
+/* check external WAV file name (and modify given file name if required) */
+/* Note: assumes that wavname may be modified */
+int
+akai_check_extwavname(char *wavname)
+{
+	u_int nlen;
+	int fd;
+	u_int k;
+
+	if (wavname==NULL){
+		return -1;
+	}
+
+	/* check if correct suffix in WAV file name */
+	nlen=(u_int)strlen(wavname);
+	if ((nlen<4)||(strncasecmp(wavname+nlen-4,".wav",4)!=0)){
+		PRINTF_ERR("invalid WAV file name\n");
+		return -1;
+	}
+#if 1
+	/* wildcard characters are not allowed */
+	for (k=0;k<nlen-4;k++){
+		if ((wavname[k]=='*')||(wavname[k]=='?')){
+			PRINTF_ERR("invalid WAV file name\n");
+			return -1;
+		}
+	}
+#endif
+	/* check if external file with given file name can be opened */
+	fd=OPEN(wavname,O_RDONLY|O_BINARY,0);
+	if (fd<0){ /* no success? */
+		/* modify name: ' ' instead of '_' for keyboard entry */
+		/* Note: assume that string in wavname may be modified */
+		for (k=0;k<nlen-4;k++){
+			if (wavname[k]=='_'){
+				wavname[k]=' ';
+			}
+		}
+		/* check if external file with (possibly) modified file name can be opened */
+		fd=OPEN(wavname,O_RDONLY|O_BINARY,0);
+		if (fd<0){ /* no success? */
+			PRINTF_ERR("cannot access WAV file\n");
+			return -1;
+		}
+	}
+	CLOSE(fd);
+
+	return 0; /* OK */
+}
+
+
+
+/* count free and bad blocks in partition */
+void
+akai_countfree_part(struct part_s *pp)
+{
+	u_int i;
+	u_int n;
+
+	if (pp==NULL){
+		return;
+	}
+
+	pp->bfree=0;
+	pp->bbad=0;
+
+	if ((!pp->valid)||(pp->fat==NULL)){
+		return;
+	}
+
+	if (pp->type==PART_TYPE_DD){
+		/* S1100/S3000 harddisk DD partition */
+		/* Note: start at cluster 1 in order to skip reserved system cluster 0 which contains partition header */
+		for (i=1;i<pp->csize;i++){
+			n=(pp->fat[i][1]<<8)+pp->fat[i][0];
+			if (n==AKAI_DDFAT_CODE_FREE){
+				pp->bfree+=AKAI_DDPART_CBLKS; /* +1 cluster */
+			}else if (n==AKAI_DDFAT_CODE_BAD){
+				pp->bbad+=AKAI_DDPART_CBLKS; /* +1 cluster */
+#if 1
+			}else if (((n>=pp->bsize)||(n<pp->bsyssize))
+					  /* Note: here, n!=AKAI_DDFAT_CODE_FREE, see check above */
+					  &&(n!=AKAI_DDFAT_CODE_SYS)
+					  &&(n!=AKAI_DDFAT_CODE_END)){ /* invalid? */
+				pp->bbad+=AKAI_DDPART_CBLKS; /* +1 cluster */
+#endif
+			}
+		}
+		return;
+	}
+
+	/* Note: start at block pp->bsyssize in order to skip reserved system blocks */
+	/*       => also avoids problem due to AKAI_FAT_CODE_SYS900FL==AKAI_FAT_CODE_FREE */
+	for (i=pp->bsyssize;i<pp->bsize;i++){
+		n=(pp->fat[i][1]<<8)+pp->fat[i][0];
+		if (n==AKAI_FAT_CODE_FREE){
+			pp->bfree++;
+		}else if (n==AKAI_FAT_CODE_BAD){
+			pp->bbad++;
+#if 1
+		}else if (((n>=pp->bsize)||(n<pp->bsyssize))
+				  /* Note: here, n!=AKAI_FAT_CODE_FREE, see check above */
+				  /* Note: here, n!=AKAI_FAT_CODE_BAD, see check above */
+				  &&(n!=AKAI_FAT_CODE_SYS900FL) /* XXX same as AKAI_FAT_CODE_FREE */
+				  &&(n!=AKAI_FAT_CODE_SYS900HD)
+				  &&(n!=AKAI_FAT_CODE_SYS)
+				  &&(n!=AKAI_FAT_CODE_DIREND900HD)
+				  &&(n!=AKAI_FAT_CODE_DIREND1000HD)
+				  &&(n!=AKAI_FAT_CODE_DIREND3000)
+				  &&(n!=AKAI_FAT_CODE_FILEEND900)
+				  &&(n!=AKAI_FAT_CODE_FILEEND)){ /* invalid? */
+			pp->bbad++;
+#endif
+		}
+	}
+}
+
+
+
+int
+akai_check_fatblk(u_int blk,u_int bsize,u_int bsyssize)
+{
+
+	if (  (blk==AKAI_FAT_CODE_FREE)
+		||(blk==AKAI_FAT_CODE_BAD)
+		||(blk==AKAI_FAT_CODE_SYS900FL) /* XXX same as AKAI_FAT_CODE_FREE */
+		||(blk==AKAI_FAT_CODE_SYS900HD)
+		||(blk==AKAI_FAT_CODE_SYS)
+		||(blk==AKAI_FAT_CODE_DIREND900HD)
+		||(blk==AKAI_FAT_CODE_DIREND1000HD)
+		||(blk==AKAI_FAT_CODE_DIREND3000)
+		||(blk==AKAI_FAT_CODE_FILEEND900)
+		||(blk==AKAI_FAT_CODE_FILEEND)
+		||(blk>=bsize)
+		||(blk<bsyssize)){
+		return -1; /* special code or invalid */
+	}
+
+	return 0; /* OK */
+}
+
+
+
+int
+print_fatchain(struct part_s *pp,u_int blk)
+{
+	u_int i;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type==PART_TYPE_DD){
+		return -1;
+	}
+
+	PRINTF_OUT("lblk    pblk\n");
+	PRINTF_OUT("--------------\n");
+	for (i=0;i<pp->bsize;i++){ /* XXX to avoid loop */
+		if (akai_check_fatblk(blk,pp->bsize,pp->bsyssize)<0){
+			break; /* end of chain */
+		}
+		PRINTF_OUT("0x%04x  0x%04x\n",i,blk);
+		/* next block */
+		blk=(pp->fat[blk][1]<<8)+pp->fat[blk][0];
+	}
+	PRINTF_OUT("--------------\n");
+#if 0
+	PRINTF_OUT("END=    0x%04x\n",blk);
+#endif
+
+	if (i==pp->bsize){ /* XXX stuck in loop? */
+		return 1;
+	}
+
+	return 0;
+}
+
+
+
+/* Note: if writeflag==0, free block counter of partition is not updated!!! */
+int
+akai_free_fatchain(struct part_s *pp,u_int bstart,int writeflag)
+{
+	int ret;
+	u_int fblk,nblk;
+	u_int bc;
+	u_int i;
+	u_int hdsiz;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)||(bstart>pp->bsize)){
+		return -1;
+	}
+	if (pp->type==PART_TYPE_DD){
+		return -1;
+	}
+
+	ret=0; /* OK so far */
+
+	/* free FAT chain */
+	fblk=bstart;
+	bc=0; /* block counter */
+	for (i=0;i<pp->bsize;i++){ /* XXX to avoid loop */
+		/* check fblk */
+		if ( /* Note: don't check for AKAI_FAT_CODE_SYS900FL here since it is ==AKAI_FAT_CODE_FREE !!! */
+			  (fblk==AKAI_FAT_CODE_SYS900HD)
+			||(fblk==AKAI_FAT_CODE_SYS)
+			||(fblk==AKAI_FAT_CODE_DIREND900HD)
+			||(fblk==AKAI_FAT_CODE_DIREND1000HD)
+			||(fblk==AKAI_FAT_CODE_DIREND3000)
+			||(fblk==AKAI_FAT_CODE_FILEEND900)
+			||(fblk==AKAI_FAT_CODE_FILEEND)){ /* valid end of chain? */
+			break; /* done */
+		}
+		if (  (fblk==AKAI_FAT_CODE_FREE)
+			||(fblk==AKAI_FAT_CODE_BAD)
+			||(fblk>=pp->bsize)){ /* invalid? */
+			PRINTF_ERR("invalid block in chain\n");
+			ret=-1;
+			break;
+		}
+		/* next block */
+		nblk=(pp->fat[fblk][1]<<8)+pp->fat[fblk][0];
+		/* free block in FAT */
+		pp->fat[fblk][1]=0xff&(AKAI_FAT_CODE_FREE>>8);
+		pp->fat[fblk][0]=0xff&AKAI_FAT_CODE_FREE;
+		bc++;
+		/* advance */
+		fblk=nblk;
+	}
+
+	if (writeflag){
+		/* update free block counter */
+		pp->bfree+=bc;
+
+		/* write new FAT to partition */
+		if ((pp->type==PART_TYPE_FLL)||(pp->type==PART_TYPE_FLH)){
+			/* write floppy header */
+			if (pp->type==PART_TYPE_FLL){
+				hdsiz=AKAI_FLLHEAD_BLKS; /* floppy header */
+			}else{
+				hdsiz=AKAI_FLHHEAD_BLKS; /* floppy header */
+			}
+			if (akai_io_blks(pp,(u_char *)&pp->head.flh,
+							 0,
+							 hdsiz,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}else if (pp->type==PART_TYPE_HD9){
+			/* copy first FAT entries */
+			bcopy((u_char *)&pp->head.hd9.fatblk,(u_char *)&pp->head.hd9.fatblk0,AKAI_HD9FAT0_ENTRIES*2);
+			/* write S900 harddisk header */
+			if (akai_io_blks(pp,(u_char *)&pp->head.hd9,
+							 0,
+							 AKAI_HD9HEAD_BLKS,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}else if (pp->type==PART_TYPE_HD){
+			/* write S1000/S3000 partition header */
+			if (akai_io_blks(pp,(u_char *)&pp->head.hd,
+							 0,
+							 AKAI_PARTHEAD_BLKS,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}
+	}
+
+	return ret;
+}
+
+
+
+/* returns first block in *bstartp */
+int
+akai_allocate_fatchain(struct part_s *pp,u_int bsize,u_int *bstartp,u_int bcont0,u_int endcode)
+{
+	int ret;
+	u_int fblk,pblk;
+	u_int bc;
+	u_int hdsiz;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type==PART_TYPE_DD){
+		return -1;
+	}
+	if (bstartp==NULL){
+		return -1;
+	}
+
+	if (bcont0>bsize){ /* want more contiguous blocks than total? */
+		return -1;
+	}
+
+	/* check if enough space left */
+	if (bsize>pp->bfree){
+		PRINTF_ERR("not enough space left\n");
+		return -1;
+	}
+	/* now there should be enough free blocks if there was no bcont0 constraint */
+
+	/* check code for end of chain */
+	if ( /* Note: don't check for AKAI_FAT_CODE_SYS900FL here since it is ==AKAI_FAT_CODE_FREE !!! */
+		  (endcode!=AKAI_FAT_CODE_SYS900HD)
+		&&(endcode!=AKAI_FAT_CODE_SYS)
+		&&(endcode!=AKAI_FAT_CODE_DIREND900HD)
+		&&(endcode!=AKAI_FAT_CODE_DIREND1000HD)
+		&&(endcode!=AKAI_FAT_CODE_DIREND3000)
+		&&(endcode!=AKAI_FAT_CODE_FILEEND900)
+		&&(endcode!=AKAI_FAT_CODE_FILEEND)){
+		return -1;
+	}
+
+	if (bsize==0){
+		return 0; /* done */
+	}
+
+	/* scan FAT */
+	ret=0; /* no error so far */
+	bc=0; /* block counter */
+	*bstartp=pp->bsize; /* invalid */
+	pblk=0;
+	/* Note: start at block pp->bsyssize in order to skip reserved system blocks */
+	/*       => also avoids problem due to AKAI_FAT_CODE_SYS900FL==AKAI_FAT_CODE_FREE */
+	for (fblk=pp->bsyssize;fblk<pp->bsize;fblk++){ /* block */
+		/* check if fblk is free */
+		if (((pp->fat[fblk][1]<<8)+pp->fat[fblk][0])!=AKAI_FAT_CODE_FREE){
+			continue; /* not free, next */
+		}
+		/* is free */
+
+		/* allocate */
+		if (bc==0){ /* is first free block? */
+			/* start of chain */
+			*bstartp=fblk;
+		}else{
+			if ((bcont0<=1)||(fblk==(pblk+1))){ /* don't care or contiguous to previous block? */
+				/* link chain in previous free block */
+				pp->fat[pblk][1]=0xff&(fblk>>8);
+				pp->fat[pblk][0]=0xff&fblk;
+			}else{
+				/* we care and this is a non-contiguous block */
+				if (bc<bcont0){ /* not enough so far? */
+					/* must discard chain allocated so far */
+					/* free chain */
+					if (akai_free_fatchain(pp,*bstartp,0)<0){ /* 0: don't write FAT yet */
+						ret=-1;
+						goto akai_allocate_fatchain_done;
+					}
+					/* nothing anymore, new start */
+					*bstartp=fblk;
+					bc=0;
+				}else{
+					/* enough contiguous blocks, non-contiguous blocks may follow now */
+					bcont0=0; /* don't care anymore */
+				}
+			}
+		}
+		bc++; /* found one */
+		/* temporarily mark end of chain */
+		pp->fat[fblk][1]=0xff&(endcode>>8);
+		pp->fat[fblk][0]=0xff&endcode;
+
+		if (bc==bsize){ /* enough? */
+			/* keep end mark */
+			break; /* done */
+		}
+		pblk=fblk; /* save for next element */
+	}
+
+	if (bc!=bsize){ /* not enough? */
+		if (*bstartp<pp->bsize){ /* valid chain? */
+			/* free chain */
+			if (akai_free_fatchain(pp,*bstartp,0)<0){ /* 0: don't write FAT yet */
+				ret=-1;
+				goto akai_allocate_fatchain_done;
+			}
+		}
+	}else{
+		/* enough */
+		/* update free block counter */
+		pp->bfree-=bc;
+	}
+
+akai_allocate_fatchain_done:
+	if (ret<0){
+		/* XXX in case something went wrong */
+		/* count free and bad blocks */
+		akai_countfree_part(pp);
+	}
+	/* write new FAT to partition */
+	if ((pp->type==PART_TYPE_FLL)||(pp->type==PART_TYPE_FLH)){
+		/* write floppy header */
+		if (pp->type==PART_TYPE_FLL){
+			hdsiz=AKAI_FLLHEAD_BLKS; /* floppy header */
+		}else{
+			hdsiz=AKAI_FLHHEAD_BLKS; /* floppy header */
+		}
+		if (akai_io_blks(pp,(u_char *)&pp->head.flh,
+						 0,
+						 hdsiz,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			ret=-1;
+		}
+	}else if (pp->type==PART_TYPE_HD9){
+		/* copy first FAT entries */
+		bcopy((u_char *)&pp->head.hd9.fatblk,(u_char *)&pp->head.hd9.fatblk0,AKAI_HD9FAT0_ENTRIES*2);
+		/* write S900 harddisk header */
+		if (akai_io_blks(pp,(u_char *)&pp->head.hd9,
+						 0,
+						 AKAI_HD9HEAD_BLKS,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			ret=-1;
+		}
+	}else if (pp->type==PART_TYPE_HD){
+		/* write S1000/S3000 partition header */
+		if (akai_io_blks(pp,(u_char *)&pp->head.hd,
+						 0,
+						 AKAI_PARTHEAD_BLKS,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			ret=-1;
+		}
+	}
+
+	return ret;
+}
+
+
+
+int
+akai_scanbad(struct part_s *pp,int markflag)
+{
+	static u_char buf[AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE]; /* XXX enough for all partition types */
+	u_int hdsiz;
+	u_int i,n;
+	int modifflag;
+
+	if ((pp==NULL)||(!pp->valid)){
+		return -1;
+	}
+
+	if (pp->type==PART_TYPE_DD){
+		/* S1100/S3000 harddisk DD partition */
+		/* scan for bad clusters */
+		modifflag=0;
+		for (i=0;i<pp->csize;i++){
+			PRINTF_OUT("\rcluster 0x%04x",i);
+			FLUSH_ALL;
+			/* try to read cluster */
+			if (akai_io_blks(pp,(u_char *)buf,
+							 i*AKAI_DDPART_CBLKS, /* block offset */
+							 AKAI_DDPART_CBLKS, /* 1 cluster */
+							 0,IO_BLKS_READ)<0){ /* 0: don't alloc cache */
+				/* cannot read cluster */
+				if (i==0){ /* reserved cluster for system? */
+					PRINTF_OUT(" bad (system)\n");
+					/* XXX don't mark system cluster as bad */
+				}else{
+					n=(pp->fat[i][1]<<8)+pp->fat[i][0];
+					if ((n==AKAI_DDFAT_CODE_FREE)||(n==AKAI_DDFAT_CODE_BAD)){
+						PRINTF_OUT(" bad\n");
+						if (markflag&&(n!=AKAI_DDFAT_CODE_BAD)){
+							/* mark as bad cluster */
+							pp->fat[i][1]=0xff&(AKAI_DDFAT_CODE_BAD>>8);
+							pp->fat[i][0]=0xff&AKAI_DDFAT_CODE_BAD;
+							modifflag=1;
+						}
+					}else{
+						PRINTF_OUT(" bad (used)\n");
+						/* XXX don't mark used cluster as bad */
+					}
+				}
+				FLUSH_ALL;
+
+				if (markflag&&modifflag){
+					/* count free and bad blocks */
+					akai_countfree_part(pp);
+
+					/* write partition header */
+					if (akai_io_blks(pp,(u_char *)&pp->head.dd,
+									 0,
+									 AKAI_DDPARTHEAD_BLKS,
+									 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+						return -1;
+					}
+				}
+			}
+		}
+		return 0;
+	}
+
+	/* scan for bad blocks */
+	modifflag=0;
+	for (i=0;i<pp->bsize;i++){
+		PRINTF_OUT("\rblock 0x%04x",i);
+		FLUSH_ALL;
+#ifdef _VISUALCPP
+		if (pp->diskp->fldrn>=0){ /* is floppy drive? */
+			/* check if no floppy inserted */
+			if (fldr_checkfloppyinserted(pp->diskp->fldrn)!=0){
+				PRINTF_OUT("\nerror: no floppy inserted\n");
+				FLUSH_ALL;
+				return -1;
+			}
+		}
+#endif /* _VISUALCPP */
+		/* try to read block */
+		if (akai_io_blks(pp,(u_char *)buf,
+						 i,
+						 1,
+						 0,IO_BLKS_READ)<0){ /* 0: don't alloc cache */
+			/* cannot read block */
+			if (i<pp->bsyssize){ /* reserved block for system? */
+				PRINTF_OUT(" bad (system)\n");
+				/* XXX don't mark system block as bad */
+			}else{
+				n=(pp->fat[i][1]<<8)+pp->fat[i][0];
+				if ((n==AKAI_FAT_CODE_FREE)||(n==AKAI_FAT_CODE_BAD)){
+					PRINTF_OUT(" bad\n");
+					if (markflag&&(n!=AKAI_FAT_CODE_BAD)){
+						/* mark as bad block */
+						pp->fat[i][1]=0xff&(AKAI_FAT_CODE_BAD>>8);
+						pp->fat[i][0]=0xff&AKAI_FAT_CODE_BAD;
+						modifflag=1;
+					}
+				}else{
+					PRINTF_OUT(" bad (used)\n");
+					/* XXX don't mark used block as bad */
+				}
+			}
+			FLUSH_ALL;
+		}
+	}
+
+	if (markflag&&modifflag){
+		/* count free and bad blocks */
+		akai_countfree_part(pp);
+
+		/* write new FAT to partition */
+		if ((pp->type==PART_TYPE_FLL)||(pp->type==PART_TYPE_FLH)){
+			/* write floppy header */
+			if (pp->type==PART_TYPE_FLL){
+				hdsiz=AKAI_FLLHEAD_BLKS; /* floppy header */
+			}else{
+				hdsiz=AKAI_FLHHEAD_BLKS; /* floppy header */
+			}
+			if (akai_io_blks(pp,(u_char *)&pp->head.flh,
+							 0,
+							 hdsiz,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}else if (pp->type==PART_TYPE_HD9){
+			/* copy first FAT entries */
+			bcopy((u_char *)&pp->head.hd9.fatblk,(u_char *)&pp->head.hd9.fatblk0,AKAI_HD9FAT0_ENTRIES*2);
+			/* write S900 harddisk header */
+			if (akai_io_blks(pp,(u_char *)&pp->head.hd9,
+							 0,
+							 AKAI_HD9HEAD_BLKS,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}else if (pp->type==PART_TYPE_HD){
+			/* write S1000/S3000 partition header */
+			if (akai_io_blks(pp,(u_char *)&pp->head.hd,
+							 0,
+							 AKAI_PARTHEAD_BLKS,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}
+	}
+
+	return 0;
+}
+
+
+
+int
+akai_read_file(int outfd,u_char *outbuf,struct file_s *fp,u_int begin,u_int end)
+{
+	u_char fbuf[AKAI_HD_BLOCKSIZE];
+	u_int fblk,fchunk,fremain,skipbyte;
+	u_char (*fatp)[2];
+	int err;
+
+	if ((outfd<0)&&(outbuf==NULL)){
+		return -1;
+	}
+
+	if (fp==NULL){
+		return -1;
+	}
+	if ((fp->volp==NULL)||(fp->volp->type==AKAI_VOL_TYPE_INACT)){
+		return -1;
+	}
+	if ((fp->volp->partp==NULL)||(!fp->volp->partp->valid)){
+		return -1;
+	}
+	fatp=fp->volp->partp->fat;
+	if (fatp==NULL){
+		return -1;
+	}
+	if ((fp->volp->partp->blksize==0)||(fp->volp->partp->blksize>AKAI_HD_BLOCKSIZE)){
+		return -1;
+	}
+
+	if (fp->type==AKAI_FTYPE_FREE){
+		return -1;
+	}
+
+	if ((end<begin)||(end>fp->size)){
+		PRINTF_ERR("invalid limits\n");
+		return -1;
+	}
+
+	fblk=fp->bstart; /* start block */
+	fremain=end; /* remaining bytes */
+	skipbyte=begin; /* bytes to skip */
+	for (;fremain>0;){ /* byte counter */
+		if (fremain>=fp->volp->partp->blksize){
+			fchunk=fp->volp->partp->blksize;
+		}else{
+			fchunk=fremain;
+		}
+		/* check fblk */
+		if (akai_check_fatblk(fblk,fp->volp->partp->bsize,fp->volp->partp->bsyssize)<0){
+			PRINTF_ERR("invalid block in file\n");
+			return -1;
+		}
+		if (skipbyte<fchunk){
+			/* read block */
+			if (akai_io_blks(fp->volp->partp,(u_char *)fbuf,
+							 fblk,
+							 1,
+							 0,IO_BLKS_READ)<0){ /* 0: don't alloc cache */
+				return -1;
+			}
+			if (outbuf!=NULL){
+				/* to buffer */
+				bcopy(fbuf+skipbyte,outbuf,fchunk-skipbyte);
+				outbuf+=fchunk-skipbyte;
+			}else{
+				/* write to file */
+				err=WRITE(outfd,(void *)(fbuf+skipbyte),fchunk-skipbyte);
+				if (err<0){
+					PERROR("write");
+					return -1;
+				}
+				if (err!=(int)(fchunk-skipbyte)){
+					PRINTF_ERR("write: incomplete\n");
+					return -1;
+				}
+			}
+			skipbyte=0; /* done */
+		}else{
+			skipbyte-=fchunk;
+		}
+		/* next block */
+		fblk=(fatp[fblk][1]<<8)+fatp[fblk][0];
+		/* chunk done */
+		fremain-=fchunk;
+	}
+
+	return 0;
+}
+
+
+
+int
+akai_write_file(int inpfd,u_char *inpbuf,struct file_s *fp,u_int begin,u_int end)
+{
+	u_char fbuf[AKAI_HD_BLOCKSIZE];
+	u_int fblk,fchunk,fremain,skipbyte;
+	u_char (*fatp)[2];
+	int err;
+
+	if ((inpfd<0)&&(inpbuf==NULL)){
+		return -1;
+	}
+
+	if (fp==NULL){
+		return -1;
+	}
+	if ((fp->volp==NULL)||(fp->volp->type==AKAI_VOL_TYPE_INACT)){
+		return -1;
+	}
+	if ((fp->volp->partp==NULL)||(!fp->volp->partp->valid)){
+		return -1;
+	}
+	fatp=fp->volp->partp->fat;
+	if (fatp==NULL){
+		return -1;
+	}
+	if ((fp->volp->partp->blksize==0)||(fp->volp->partp->blksize>AKAI_HD_BLOCKSIZE)){
+		return -1;
+	}
+
+	if (fp->type==AKAI_FTYPE_FREE){
+		return -1;
+	}
+
+	if ((end<begin)||(end>fp->size)){
+		PRINTF_ERR("invalid limits\n");
+		return -1;
+	}
+
+	fblk=fp->bstart; /* start block */
+	fremain=end; /* remaining bytes */
+	skipbyte=begin; /* bytes to skip */
+	for (;fremain>0;){ /* byte counter */
+		if (fremain>=fp->volp->partp->blksize){
+			fchunk=fp->volp->partp->blksize;
+		}else{
+			fchunk=fremain;
+		}
+		/* check fblk */
+		if (akai_check_fatblk(fblk,fp->volp->partp->bsize,fp->volp->partp->bsyssize)<0){
+			PRINTF_ERR("invalid block in file\n");
+			return -1;
+		}
+		if (skipbyte<fchunk){
+			if ((skipbyte>0)||(fchunk<fp->volp->partp->blksize)){ /* need to read? */
+				/* read block */
+				if (akai_io_blks(fp->volp->partp,(u_char *)fbuf,
+								 fblk,
+								 1,
+								 0,IO_BLKS_READ)<0){ /* 0: don't alloc cache */
+					return -1;
+				}
+			}
+			if (inpbuf!=NULL){
+				/* from buffer */
+				bcopy(inpbuf,fbuf+skipbyte,fchunk-skipbyte);
+				inpbuf+=fchunk-skipbyte;
+			}else{
+				/* read file */
+				err=READ(inpfd,(void *)(fbuf+skipbyte),fchunk-skipbyte);
+				if (err<0){
+					PERROR("read");
+					return -1;
+				}
+				if (err!=(int)(fchunk-skipbyte)){
+					PRINTF_ERR("read: incomplete\n");
+					return -1;
+				}
+			}
+			/* write block */
+			if (akai_io_blks(fp->volp->partp,(u_char *)fbuf,
+							 fblk,
+							 1,
+							 0,IO_BLKS_WRITE)<0){ /* 0: don't alloc cache */
+				return -1;
+			}
+			skipbyte=0; /* done */
+		}else{
+			skipbyte-=fchunk;
+		}
+		/* next block */
+		fblk=(fatp[fblk][1]<<8)+fatp[fblk][0];
+		/* chunk done */
+		fremain-=fchunk;
+	}
+
+	return 0;
+}
+
+
+
+int
+print_ddfatchain(struct part_s *pp,u_int cstart)
+{
+	u_int i;
+	u_int cl,nextcl;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+	if (cstart>=pp->csize){
+		return -1;
+	}
+
+	PRINTF_OUT("lcl     pcl\n");
+	PRINTF_OUT("--------------\n");
+	cl=cstart;
+	for (i=0;i<pp->csize;i++){ /* XXX to avoid loop */
+		/* check cl */
+		if ((cl==AKAI_DDFAT_CODE_FREE)
+			||(cl==AKAI_DDFAT_CODE_BAD)
+			||(cl==AKAI_DDFAT_CODE_SYS)
+			||(cl==AKAI_DDFAT_CODE_END)
+			||(cl>=pp->csize)){ /* invalid? */
+			break; /* exit */
+		}
+		/* next cluster */
+		nextcl=(pp->fat[cl][1]<<8)+pp->fat[cl][0];
+		/* print */
+		PRINTF_OUT("0x%04x  0x%04x\n",i,cl);
+		/* advance */
+		if (nextcl==AKAI_DDFAT_CODE_END){
+			break; /* end of chain */
+		}
+		cl=nextcl;
+	}
+	PRINTF_OUT("--------------\n");
+#if 0
+	PRINTF_OUT("END=    0x%04x\n",cl);
+#endif
+
+	if (i==pp->csize){ /* XXX stuck in loop? */
+		return 1;
+	}
+
+	return 0;
+}
+
+
+
+u_int
+akai_count_ddfatchain(struct part_s *pp,u_int cstart)
+{
+	u_int cc;
+	u_int i;
+	u_int cl,nextcl;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return 0;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return 0;
+	}
+	if (cstart>=pp->csize){
+		return 0;
+	}
+
+	cc=0;
+	cl=cstart;
+	for (i=0;i<pp->csize;i++){ /* XXX to avoid loop */
+		/* check cl */
+		if ((cl==AKAI_DDFAT_CODE_FREE)
+			||(cl==AKAI_DDFAT_CODE_BAD)
+			||(cl==AKAI_DDFAT_CODE_SYS)
+			||(cl==AKAI_DDFAT_CODE_END)
+			||(cl>=pp->csize)){ /* invalid? */
+			break; /* exit */
+		}
+		/* next cluster */
+		nextcl=(pp->fat[cl][1]<<8)+pp->fat[cl][0];
+		cc++; /* +1 cluster */
+		/* advance */
+		if (nextcl==AKAI_DDFAT_CODE_END){
+			break; /* end of chain, done */
+		}
+		cl=nextcl;
+	}
+
+	return cc;
+}
+
+
+
+/* Note: if writeflag==0, free block counter of partition is not updated!!! */
+int
+akai_free_ddfatchain(struct part_s *pp,u_int cstart,int writeflag)
+{
+	int ret;
+	u_int cl,nextcl;
+	u_int cc;
+	u_int i;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)||(cstart>pp->csize)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+
+	ret=0; /* OK so far */
+
+	/* free DD FAT chain */
+	cl=cstart;
+	cc=0; /* cluster counter */
+	for (i=0;i<pp->csize;i++){ /* XXX to avoid loop */
+		/* check cl */
+		if ((cl==AKAI_DDFAT_CODE_FREE)
+			||(cl==AKAI_DDFAT_CODE_BAD)
+			||(cl==AKAI_DDFAT_CODE_SYS)
+			||(cl==AKAI_DDFAT_CODE_END)
+			||(cl>=pp->csize)){ /* invalid? */
+			PRINTF_ERR("invalid cluster in chain\n");
+			ret=-1;
+			break;
+		}
+		/* next cluster */
+		nextcl=(pp->fat[cl][1]<<8)+pp->fat[cl][0];
+		/* free cluster in FAT */
+		pp->fat[cl][1]=0xff&(AKAI_DDFAT_CODE_FREE>>8);
+		pp->fat[cl][0]=0xff&AKAI_DDFAT_CODE_FREE;
+		cc++;
+		/* advance */
+		if (nextcl==AKAI_DDFAT_CODE_END){
+			break; /* end of chain, done */
+		}
+		cl=nextcl;
+	}
+
+	if (writeflag){
+		/* update free block counter */
+		pp->bfree+=cc*AKAI_DDPART_CBLKS;
+
+		/* write partition header */
+		if (akai_io_blks(pp,(u_char *)&pp->head.dd,
+						 0,
+						 AKAI_DDPARTHEAD_BLKS,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			return -1;
+		}
+	}
+
+	return ret;
+}
+
+
+
+/* returns first cluster in *cstartp */
+int
+akai_allocate_ddfatchain(struct part_s *pp,u_int csize,u_int *cstartp,u_int ccont0)
+{
+	int ret;
+	u_int fcl,pcl;
+	u_int cc;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+	if (cstartp==NULL){
+		return -1;
+	}
+
+	if (ccont0>csize){ /* want more contiguous clusters than total? */
+		return -1;
+	}
+
+	/* check if enough space left */
+	if (csize*AKAI_DDPART_CBLKS>pp->bfree){
+		PRINTF_ERR("not enough space left\n");
+		return -1;
+	}
+	/* now there should be enough free clusters if there was no ccont0 constraint */
+
+	if (csize==0){
+		return 0; /* done */
+	}
+
+	/* scan FAT */
+	ret=0; /* no error so far */
+	cc=0; /* cluster counter */
+	*cstartp=pp->csize; /* invalid */
+	pcl=0;
+	/* Note: start at cluster 1 in order to skip reserved system cluster 0 which contains partition header */
+	for (fcl=1;fcl<pp->csize;fcl++){ /* cluster */
+		/* check if fcl is free */
+		if (((pp->fat[fcl][1]<<8)+pp->fat[fcl][0])!=AKAI_DDFAT_CODE_FREE){
+			continue; /* not free, next */
+		}
+		/* is free */
+
+		/* allocate */
+		if (cc==0){ /* is first free cluster? */
+			/* start of chain */
+			*cstartp=fcl;
+		}else{
+			if ((ccont0<=1)||(fcl==(pcl+1))){ /* don't care or contiguous to previous cluster? */
+				/* link chain in previous free cluster */
+				pp->fat[pcl][1]=0xff&(fcl>>8);
+				pp->fat[pcl][0]=0xff&fcl;
+			}else{
+				/* we care and this is a non-contiguous cluster */
+				if (cc<ccont0){ /* not enough so far? */
+					/* must discard chain allocated so far */
+					/* free chain */
+					if (akai_free_ddfatchain(pp,*cstartp,0)<0){ /* 0: don't write FAT yet */
+						ret=-1;
+						goto akai_allocate_ddfatchain_done;
+					}
+					/* nothing anymore, new start */
+					*cstartp=fcl;
+					cc=0;
+				}else{
+					/* enough contiguous clusters, non-contiguous clusters may follow now */
+					ccont0=0; /* don't care anymore */
+				}
+			}
+		}
+		cc++; /* found one */
+		/* temporarily mark end of chain */
+		pp->fat[fcl][1]=0xff&(AKAI_DDFAT_CODE_END>>8);
+		pp->fat[fcl][0]=0xff&AKAI_DDFAT_CODE_END;
+
+		if (cc==csize){ /* enough? */
+			/* keep end mark */
+			break; /* done */
+		}
+		pcl=fcl; /* save for next element */
+	}
+
+	if (cc!=csize){ /* not enough? */
+		if (*cstartp<pp->csize){ /* valid chain? */
+			/* free chain */
+			if (akai_free_ddfatchain(pp,*cstartp,0)<0){ /* 0: don't write FAT yet */
+				ret=-1;
+				goto akai_allocate_ddfatchain_done;
+			}
+		}
+	}else{
+		/* enough */
+		/* update free block counter */
+		pp->bfree-=cc*AKAI_DDPART_CBLKS;
+	}
+
+akai_allocate_ddfatchain_done:
+	if (ret<0){
+		/* XXX in case something went wrong */
+		/* count free and bad blocks */
+		akai_countfree_part(pp);
+	}
+	/* write partition header */
+	if (akai_io_blks(pp,(u_char *)&pp->head.dd,
+					 0,
+					 AKAI_DDPARTHEAD_BLKS,
+					 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+		ret=-1;
+	}
+
+	return ret;
+}
+
+
+
+int
+akai_export_ddfatchain(struct part_s *pp,u_int cstart,u_int bstart,u_int bsize,int outfd,u_char *outbuf)
+{
+	static u_char buf[AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE];
+	u_int bufsiz;
+	u_int i,i0,i1;
+	u_int cl,nextcl;
+	u_int chunkoff,chunksiz;
+	int err;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+	if (cstart>=pp->csize){
+		return -1;
+	}
+	if ((outfd<0)&&(outbuf==NULL)){
+		return -1;
+	}
+
+	if (bsize==0){
+		return 0;
+	}
+
+	bufsiz=AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE; /* 1 cluster in bytes */
+
+	i0=bstart/bufsiz; /* first cluster for export */
+	i1=(bstart+bsize-1)/bufsiz; /* last cluster for export */
+	if (i1>=pp->csize){
+		return -1;
+	}
+
+	cl=cstart;
+	for (i=0;i<=i1;i++){
+		/* check cl */
+		if ((cl==AKAI_DDFAT_CODE_FREE)
+			||(cl==AKAI_DDFAT_CODE_BAD)
+			||(cl==AKAI_DDFAT_CODE_SYS)
+			||(cl==AKAI_DDFAT_CODE_END)
+			||(cl>=pp->csize)){ /* invalid? */
+			return -1;
+		}
+		/* next cluster */
+		nextcl=(pp->fat[cl][1]<<8)+pp->fat[cl][0];
+
+		if (i>=i0){ /* far enough? */
+			/* read cluster */
+			if (akai_io_blks(pp,buf,
+							 cl*AKAI_DDPART_CBLKS, /* block offset */
+							 AKAI_DDPART_CBLKS, /* 1 cluster */
+							 1,IO_BLKS_READ)<0){  /* 1: alloc cache if possible */
+				return -1;
+			}
+
+			if (i==i0){ /* first cluster? */
+				chunkoff=bstart-i0*bufsiz;
+				chunksiz=bufsiz-chunkoff;
+				/* Note: chunkoff and chunksiz <= bufsiz by definition of i0 */
+				if (chunksiz>bsize){
+					chunksiz=bsize;
+				}
+			}else if (i==i1){ /* last cluster? */
+				chunkoff=0;
+				chunksiz=bstart+bsize-i1*bufsiz;
+				/* Note: chunksiz <= bufsiz by definition of i1 */
+			}else{
+				chunkoff=0;
+				chunksiz=bufsiz; /* 1 cluster */
+			}
+
+			if (outbuf!=NULL){
+				/* to buffer */
+				bcopy(buf+chunkoff,outbuf,chunksiz);
+				outbuf+=chunksiz;
+			}else{
+				/* write to file */
+				err=WRITE(outfd,buf+chunkoff,chunksiz);
+				if (err<0){
+					PERROR("write");
+					return -1;
+				}
+				if (err!=(int)chunksiz){
+					PRINTF_ERR("write: incomplete\n");
+					return -1;
+				}
+			}
+		}
+
+		/* advance */
+		if (nextcl==AKAI_DDFAT_CODE_END){
+			break; /* end of chain, done */
+		}
+		cl=nextcl;
+	}
+
+	return 0;
+}
+
+
+
+int
+akai_import_ddfatchain(struct part_s *pp,u_int cstart,u_int bstart,u_int bsize,int inpfd,u_char *inpbuf)
+{
+	static u_char buf[AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE];
+	u_int bufsiz;
+	u_int i,i0,i1;
+	u_int cl,nextcl;
+	u_int chunkoff,chunksiz;
+	int readflag;
+	int err;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+	if (cstart>=pp->csize){
+		return -1;
+	}
+	if ((inpfd<0)&&(inpbuf==NULL)){
+		return -1;
+	}
+
+	if (bsize==0){
+		return 0;
+	}
+
+	bufsiz=AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE; /* 1 cluster in bytes */
+
+	i0=bstart/bufsiz; /* first cluster for export */
+	i1=(bstart+bsize-1)/bufsiz; /* last cluster for export */
+	if (i1>=pp->csize){
+		return -1;
+	}
+
+	cl=cstart;
+	for (i=0;i<=i1;i++){
+		/* check cl */
+		if ((cl==AKAI_DDFAT_CODE_FREE)
+			||(cl==AKAI_DDFAT_CODE_BAD)
+			||(cl==AKAI_DDFAT_CODE_SYS)
+			||(cl==AKAI_DDFAT_CODE_END)
+			||(cl>=pp->csize)){ /* invalid? */
+			return -1;
+		}
+		/* next cluster */
+		nextcl=(pp->fat[cl][1]<<8)+pp->fat[cl][0];
+
+		if (i>=i0){ /* far enough? */
+			if (i==i0){ /* first cluster? */
+				chunkoff=bstart-i0*bufsiz;
+				chunksiz=bufsiz-chunkoff;
+				/* Note: chunkoff and chunksiz <= bufsiz by definition of i0 */
+				if (chunksiz>bsize){
+					chunksiz=bsize;
+				}
+				readflag=1;
+			}else if (i==i1){ /* last cluster? */
+				chunkoff=0;
+				chunksiz=bstart+bsize-i1*bufsiz;
+				/* Note: chunksiz <= bufsiz by definition of i1 */
+				readflag=1;
+			}else{
+				chunkoff=0;
+				chunksiz=bufsiz; /* 1 cluster */
+				readflag=0;
+			}
+
+			if (readflag){
+				/* read cluster */
+				if (akai_io_blks(pp,buf,
+								 cl*AKAI_DDPART_CBLKS, /* block offset */
+								 AKAI_DDPART_CBLKS, /* 1 cluster */
+								 1,IO_BLKS_READ)<0){  /* 1: alloc cache if possible */
+					return -1;
+				}
+			}
+
+			if (inpbuf!=NULL){
+				/* from buffer */
+				bcopy(inpbuf,buf+chunkoff,chunksiz);
+				inpbuf+=chunksiz;
+			}else{
+				/* read from file */
+				err=READ(inpfd,buf+chunkoff,chunksiz);
+				if (err<0){
+					PERROR("read");
+					return -1;
+				}
+				if (err!=(int)chunksiz){
+					PRINTF_ERR("read: incomplete\n");
+					return -1;
+				}
+			}
+
+			/* write cluster */
+			if (akai_io_blks(pp,buf,
+							 cl*AKAI_DDPART_CBLKS, /* block offset */
+							 AKAI_DDPART_CBLKS, /* 1 cluster */
+							 1,IO_BLKS_WRITE)<0){  /* 1: alloc cache if possible */
+				return -1;
+			}
+		}
+
+		/* advance */
+		if (nextcl==AKAI_DDFAT_CODE_END){
+			break; /* end of chain, done */
+		}
+		cl=nextcl;
+	}
+
+	return 0;
+}
+
+
+
+/* convert char for S1000/S3000 */
+char
+akai2ascii(u_char c)
+{
+	char a;
+
+	if (c<=9){
+		a='0'+c-0;
+	}else if (c==10){
+		a=' ';
+	}else if ((c>=11)&&(c<=36)){
+		a='A'+c-11;
+	}else if (c==37){
+		a='#';
+	}else if (c==38){
+		a='+';
+	}else if (c==39){
+		a='-';
+	}else if (c==40){
+		a='.';
+	}else{
+		a='.'; /* XXX */
+	}
+
+	return a;
+}
+
+/* convert char for S900 */
+char
+akai2ascii900(u_char c)
+{
+	char a;
+
+	if (((c>='0')&&(c<='9'))
+		||(c==' ')
+		||((c>='A')&&(c<='Z'))
+		||((c>='a')&&(c<='z'))
+		||(c=='#')
+		||(c=='+')
+		||(c=='-')
+		||(c=='.')){
+		a=c;
+	}else if (c=='\0'){
+		a=' '; /* XXX */
+	}else{
+		a='.'; /* XXX */
+	}
+
+	return a;
+}
+
+void
+akai2ascii_name(u_char *aname,char *name,int s900flag)
+{
+	int i;
+	int len;
+
+	if (name==NULL){
+		return;
+	}
+	if (aname==NULL){
+		name[0]='\0';
+		return;
+	}
+
+	if (s900flag){
+		len=AKAI_NAME_LEN_S900;
+	}else{
+		len=AKAI_NAME_LEN;
+	}
+	for (i=0;i<len;i++){
+		if (s900flag){
+#if 1
+			if (aname[i]=='\0'){ /* end? */
+				len=i;
+				break; /* done */
+			}
+#endif
+			name[i]=akai2ascii900(aname[i]);
+		}else{
+			name[i]=akai2ascii(aname[i]);
+		}
+	}
+	name[len]='\0';
+
+	/* remove trailing ' ' */
+	for (i=0;i<len;i++){
+		if (name[len-i-1]==' '){
+			name[len-i-1]='\0';
+		}else{
+			break;
+		}
+	}
+}
+
+void
+akai2ascii_filename(u_char *aname,u_char ft,u_int osver,char *name,int s900flag)
+{
+	int l;
+
+	if (name==NULL){
+		return;
+	}
+
+	/* Note: aname==NULL is also OK */
+	if (aname==NULL){
+		name[0]='\0';
+	}else{
+		akai2ascii_name(aname,name,s900flag);
+	}
+
+	/* type */
+	l=(int)strlen(name);
+	if (ft==AKAI_SAMPLE900_FTYPE){
+		/* S900 sample file */
+		if (osver!=0){
+			/* S900 compressed sample format */
+			sprintf(name+l,".S9C");
+		}else{
+			/* S900 non-compressed sample format */
+			sprintf(name+l,".S9");
+		}
+	}else if (ft==AKAI_CDSETUP3000_FTYPE){
+		/* CD3000 CD-ROM setup file */
+		/* Note: not ".T9" */
+		sprintf(name+l,".CD");
+	}else if (ft==AKAI_CDSAMPLE3000_FTYPE){
+		/* CD3000 CD-ROM sample parameters file */
+		/* Note: not ".H3" */
+		sprintf(name+l,".s+");
+	}else if ((ft>=AKAI_S900_FTYPE_MIN)&&(ft<=AKAI_S900_FTYPE_MAX)){
+		/* S900 */
+		/* Note: 'T'==AKAI_CDSETUP3000_FTYPE was handled above */
+		sprintf(name+l,".%c9",(char)('A'+ft-AKAI_S900_FTYPE_MIN));
+	}else if ((ft>=AKAI_S1000_FTYPE_MIN)&&(ft<=AKAI_S1000_FTYPE_MAX)){
+		/* S1000 */
+#if 1
+		if ((ft=='p')||(ft=='s')){
+			sprintf(name+l,".%c1",(char)('A'+ft-AKAI_S1000_FTYPE_MIN));
+		}else
+#endif
+		{
+			sprintf(name+l,".%c",(char)('A'+ft-AKAI_S1000_FTYPE_MIN));
+		}
+	}else if ((ft>=(u_char)AKAI_S3000_FTYPE_MIN)&&(ft<=(u_char)AKAI_S3000_FTYPE_MAX)){
+		/* S3000 */
+		/* Note: 'h'+0x80==AKAI_CDSAMPLE3000_FTYPE was handled above */
+		sprintf(name+l,".%c3",(char)('A'+ft-AKAI_S3000_FTYPE_MIN));
+	}else{
+		/* unknown */
+		sprintf(name+l,".x%02x",(u_int)ft);
+	}
+}
+
+/* convert char for S1000/S3000 */
+u_char
+ascii2akai(char a)
+{
+	char c;
+
+	if (a=='_'){ /* for keyboard entry */
+		a=' ';
+	}
+
+	if ((a>='0')&&(a<='9')){
+		c=a-'0';
+	}else if (a==' '){
+		c=10;
+	}else if ((a>='A')&&(a<='Z')){
+		c=11+a-'A';
+	}else if ((a>='a')&&(a<='z')){
+		c=11+a-'a';
+	}else if (a=='#'){
+		c=37;
+	}else if (a=='+'){
+		c=38;
+	}else if (a=='-'){
+		c=39;
+	}else if (a=='.'){
+		c=40;
+	}else{
+		c=40; /* XXX */
+	}
+
+	return c;
+}
+
+/* convert char for S900 */
+u_char
+ascii2akai900(char a)
+{
+	char c;
+
+	if (a=='_'){ /* for keyboard entry */
+		a=' ';
+	}
+
+	if (((a>='0')&&(a<='9'))
+		||(a==' ')
+		||((a>='A')&&(a<='Z'))
+		||((a>='a')&&(a<='z'))
+		||(a=='#')
+		||(a=='+')
+		||(a=='-')
+		||(a=='.')){
+		c=a;
+	}else{
+		c='.'; /* XXX */
+	}
+
+	return c;
+}
+
+void
+ascii2akai_name(char *name,u_char *aname,int s900flag)
+{
+	int i;
+	u_char blank;
+	int len;
+
+	if (aname==NULL){
+		return;
+	}
+
+	/* fill with default ' ' */
+	if (s900flag){
+		blank=ascii2akai900(' ');
+		len=AKAI_NAME_LEN_S900;
+	}else{
+		blank=ascii2akai(' ');
+		len=AKAI_NAME_LEN;
+	}
+	for (i=0;i<len;i++){
+		if ((name==NULL)||(name[i]=='\0')){ /* nothing or end? */
+			aname[i]=blank; /* default */
+			name=NULL; /* don't want to go beyond end */
+		}else{
+			if (s900flag){
+				aname[i]=ascii2akai900(name[i]);
+			}else{
+				aname[i]=ascii2akai(name[i]);
+			}
+		}
+	}
+}
+
+u_char
+ascii2akai_filename(char *name,u_char *aname,u_int *osverp,int s900flag)
+{
+	char *tn;
+	u_int tl;
+	u_int i,l;
+	u_int u;
+	u_char ft;
+	char namebuf[AKAI_NAME_LEN+4+1]; /* +4 for ".<type>", +1 for '\0' */
+
+	if ((aname==NULL)||(osverp==NULL)){
+		return 0; /* XXX */
+	}
+
+	l=(u_int)strlen(name);
+	/* check prior to strcpy */
+	if (l>AKAI_NAME_LEN+4){ /* too long for namebuf? */
+		/* invalid length */
+		return AKAI_FTYPE_FREE;
+	}
+
+	/* copy name for possible manipulation below */
+	strcpy(namebuf,name);
+
+	/* check length and suffix */
+	if ((l>=2)&&(l<=AKAI_NAME_LEN+2)&&(namebuf[l-2]=='.')){
+		namebuf[l-2]='\0'; /* separate */
+		tn=&namebuf[l-1]; /* type field */
+		tl=1; /* type length */
+	}else if ((l>=3)&&(l<=AKAI_NAME_LEN+3)&&(namebuf[l-3]=='.')){
+		namebuf[l-3]='\0'; /* separate */
+		tn=&namebuf[l-2]; /* type field */
+		tl=2; /* type length */
+	}else if ((l>=4)&&(l<=AKAI_NAME_LEN+4)&&(namebuf[l-4]=='.')){
+		namebuf[l-4]='\0'; /* separate */
+		tn=&namebuf[l-3]; /* type field */
+		tl=3; /* type length */
+	}else{
+		/* no valid suffix */
+		return AKAI_FTYPE_FREE;
+	}
+	l=(u_int)strlen(namebuf);
+	/* remove trailing ' ' or '_' (XXX don't care how many) */
+	for (i=0;i<l;i++){
+		if ((namebuf[l-i-1]==' ')||(namebuf[l-i-1]=='_')){
+			namebuf[l-i-1]='\0';
+		}else{
+			break;
+		}
+	}
+	/* check name length */
+	l=(u_int)strlen(namebuf);
+	if (l>(u_int)(s900flag?AKAI_NAME_LEN_S900:AKAI_NAME_LEN)){
+		/* invalid length */
+		return AKAI_FTYPE_FREE;
+	}
+
+	/* type */
+	if ((tl==2)&&(strcasecmp(tn,"S9")==0)){
+		/* S900 sample file, non-compressed sample format */
+		ft=AKAI_SAMPLE900_FTYPE;
+		/* Note: set osver, even if not S900 volume */
+		*osverp=0; /* non-compressed */
+	}else if ((tl==3)&&(strcasecmp(tn,"S9C")==0)){
+		/* S900 sample file, compressed sample format */
+		ft=AKAI_SAMPLE900_FTYPE;
+		/* Note: check/set osver, even if not S900 volume */
+		if (*osverp==0){ /* unsuitable osver? */
+			*osverp=1; /* XXX non zero */
+		}
+	}else if ((tl==2)&&(strcasecmp(tn,"CD")==0)){
+		/* CD3000 CD-ROM setup file */
+		/* Note: AKAI_CDSETUP3000_FTYPE=='T' => ".T9" will also lead to this type */
+		ft=AKAI_CDSETUP3000_FTYPE;
+		if (s900flag){
+			*osverp=0; /* non-compressed */
+		}
+	}else if ((tl==2)&&(strcasecmp(tn,"s+")==0)){
+		/* CD3000 CD-ROM sample parameters file */
+		/* Note: AKAI_CDSAMPLE3000_FTYPE=='h'+0x80 => ".H3" will also lead to this type */
+		ft=AKAI_CDSAMPLE3000_FTYPE;
+		if (s900flag){
+			*osverp=0; /* non-compressed */
+		}
+	}else if ((tl==1)||(tl==2)){
+		ft=(u_char)tn[0];
+		if ((ft>='A')&&(ft<='Z')){
+			ft+='a'-'A'; /* to lower case */
+		}
+		if ((ft<'a')||(ft>'z')){
+			/* invalid suffix */
+			ft=AKAI_FTYPE_FREE;
+		}
+		if ((tl==1)||(tn[1]=='1')){
+			/* S1000 */
+			ft=AKAI_S1000_FTYPE_MIN+ft-'a';
+		}else if (tn[1]=='9'){
+			/* S900 */
+			ft=AKAI_S900_FTYPE_MIN+ft-'a';
+			*osverp=0; /* non-compressed */
+		}else if (tn[1]=='3'){
+			/* S3000 */
+			ft=AKAI_S3000_FTYPE_MIN+ft-'a';
+		}else{
+			/* invalid suffix */
+			ft=AKAI_FTYPE_FREE;
+		}
+		if (s900flag){
+			*osverp=0; /* non-compressed */
+		}
+	}else{ /* must be tl==3 now */
+		if (((tn[0]!='X')&&(tn[0]!='x'))
+			||
+			(((tn[1]<'0')||(tn[1]>'9'))
+			 &&((tn[1]<'A')||(tn[1]>'F'))
+			 &&((tn[1]<'a')||(tn[1]>'f')))
+			||
+			(((tn[2]<'0')||(tn[2]>'9'))
+			 &&((tn[2]<'A')||(tn[2]>'F'))
+			 &&((tn[2]<'a')||(tn[2]>'f')))){
+			/* invalid suffix */
+			ft=AKAI_FTYPE_FREE;
+		}else{
+			u=AKAI_FTYPE_FREE; /* default: invalid */
+			sscanf(tn+1,"%x",&u);
+			/* Note: if sscanf finds nothing, u remains! */
+			ft=(u_char)u;
+			/* Note: might still be invalid */
+		}
+		if (s900flag){
+			*osverp=0; /* non-compressed */
+		}
+	}
+
+	/* name */
+	ascii2akai_name(namebuf,aname,s900flag);
+
+#if 1
+	if (ft==AKAI_VOLDIR3000FL_FTYPE){ /* S3000 floppy flag? */
+		ft=AKAI_FTYPE_FREE; /* invalid */
+	}
+#endif
+
+	/* Note: caller must check for AKAI_FTYPE_FREE as invalid code */
+	return ft;
+}
+
+
+
+void
+akai_vol_info(struct vol_s *vp,u_int ai,int verbose)
+{
+
+	if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)
+		||(vp->partp==NULL)||(!vp->partp->valid)){
+		return;
+	}
+
+	if (verbose){
+#if 1
+		if ((vp->partp->type==PART_TYPE_FLL)||(vp->partp->type==PART_TYPE_FLH)){ /* floppy? */
+			/* for floppy, print also some info about partition: */
+			/* Note: floppy has only one volume within one partition which covers the whole disk */
+			PRINTF_OUT("parttype:    ");
+			if (vp->partp->type==PART_TYPE_FLL){
+				PRINTF_OUT("low-density floppy");
+			}else{
+				PRINTF_OUT("high-density floppy");
+			}
+			PRINTF_OUT("\nblksize:     0x%04x bytes\n",vp->partp->blksize);
+			PRINTF_OUT("size:        0x%04x blocks (%6u KB)\n",
+				vp->partp->bsize,
+				(vp->partp->bsize*vp->partp->blksize)/1024); /* in KB */
+			PRINTF_OUT("free:        0x%04x blocks (%6u KB) = %5.1lf%%\n",
+				vp->partp->bfree,
+				(vp->partp->bfree*vp->partp->blksize)/1024, /* in KB */
+				(vp->partp->bsize>0)?(100.0*((double)vp->partp->bfree)/((double)vp->partp->bsize)):0.0);
+			PRINTF_OUT("bad:         0x%04x blocks (%6u KB) = %5.1lf%%\n",
+				vp->partp->bbad,
+				(vp->partp->bbad*vp->partp->blksize)/1024, /* in KB */
+				(vp->partp->bsize>0)?(100.0*((double)vp->partp->bbad)/((double)vp->partp->bsize)):0.0);
+		}
+#endif
+		PRINTF_OUT("vnr:         %u\n",vp->index+1);
+		PRINTF_OUT("vname:       \"%s\"\n",vp->name);
+		if (vp->partp->type==PART_TYPE_HD9){
+			if (ai>0){
+				PRINTF_OUT("alias:       V%u\n",ai);
+			}
+		}else if (vp->type!=AKAI_VOL_TYPE_S900){
+			PRINTF_OUT("load number: ");
+			akai_print_lnum(vp->lnum);
+			PRINTF_OUT("\n");
+		}
+		PRINTF_OUT("voltype:     ");
+	}else{
+		PRINTF_OUT("%3u   %-12s   ",vp->index+1,vp->name);
+		if (vp->partp->type==PART_TYPE_HD9){
+			PRINTF_OUT("V%-3u",ai);
+		}else{
+			akai_print_lnum(vp->lnum);
+		}
+		PRINTF_OUT("    0x%04x  ",vp->dirblk[0]);
+		if (vp->type!=AKAI_VOL_TYPE_S900){
+			PRINTF_OUT("%2u.%02u  ",0xff&(vp->osver>>8),0xff&vp->osver);
+		}else{
+			PRINTF_OUT(" -     ");
+		}
+	}
+	switch (vp->type){
+	case AKAI_VOL_TYPE_INACT:
+		PRINTF_OUT("INACT");
+		break;
+	case AKAI_VOL_TYPE_S1000:
+		PRINTF_OUT("S1000");
+		break;
+	case AKAI_VOL_TYPE_S3000:
+		PRINTF_OUT("S3000");
+		break;
+	case AKAI_VOL_TYPE_CD3000:
+		PRINTF_OUT("CD3000");
+		break;
+	case AKAI_VOL_TYPE_S900:
+		PRINTF_OUT("S900");
+		break;
+	default:
+		PRINTF_OUT("(%02x)",vp->type);
+		break;
+	}
+	PRINTF_OUT("\n");
+	if (verbose){
+		if (vp->type!=AKAI_VOL_TYPE_S900){
+			PRINTF_OUT("osver:       %u.%02u\n",0xff&(vp->osver>>8),0xff&vp->osver);
+		}
+		PRINTF_OUT("start:       block 0x%04x\n",vp->dirblk[0]);
+		PRINTF_OUT("max. files:  %u\n",vp->fimax);
+	}
+}
+
+void
+akai_list_vol(struct vol_s *vp,u_char *filtertagp)
+{
+	u_int fi;
+	struct file_s tmpfile; /* current file */
+	u_int totf,totb;
+
+	if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)
+		||(vp->partp==NULL)||(!vp->partp->valid)
+		||(vp->partp->diskp==NULL)){
+		return;
+	}
+
+	PRINTF_OUT("/disk%u/%c/%s\n",vp->partp->diskp->index,vp->partp->letter,vp->name);
+	if (vp->type==AKAI_VOL_TYPE_S900){
+		PRINTF_OUT("fnr  fname               size/B  startblk  uncompr\n");
+		PRINTF_OUT("--------------------------------------------------\n");
+	}else{
+		PRINTF_OUT("fnr  fname               size/B  startblk  osver  tags\n");
+		PRINTF_OUT("--------------------------------------------------------------\n");
+	}
+
+	/* files in volume directory */
+	totf=0;
+	totb=0;
+	for (fi=0;fi<vp->fimax;fi++){
+		/* get file */
+		if (akai_get_file(vp,&tmpfile,fi)<0){
+			continue; /* next file */
+		}
+		/* test if tag-filter matches */
+		if (akai_match_filetags(filtertagp,tmpfile.tag)<0){ /* no match? */
+			continue; /* next file */
+		}
+		totf++;
+		totb+=tmpfile.size;
+		/* print file info */
+		akai_file_info(&tmpfile,0);
+	}
+
+	if (vp->type==AKAI_VOL_TYPE_S900){
+		PRINTF_OUT("--------------------------------------------------\n");
+	}else{
+		PRINTF_OUT("--------------------------------------------------------------\n");
+	}
+	PRINTF_OUT("total: %3u file(s) (max. %3u), %9u bytes\n\n",totf,vp->fimax,totb);
+}
+
+
+
+int
+akai_read_voldir(struct vol_s *vp)
+{
+	u_int i,imax;
+	u_int blk;
+	u_char *addr;
+
+	if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)||(vp->file==NULL)){
+		return -1;
+	}
+	if ((vp->partp==NULL)||(!vp->partp->valid)||(vp->partp->blksize==0)){
+		return -1;
+	}
+
+	/* number of blocks */
+	imax=vp->fimax*sizeof(struct akai_voldir_entry_s);
+	imax=(imax+vp->partp->blksize-1)/vp->partp->blksize; /* round up */
+	if (imax>VOL_DIRBLKS){
+		return -1;
+	}
+
+	/* Note: first file starts at byte 0 in first block */
+	addr=(u_char *)vp->file;
+	for (i=0;i<imax;i++){
+		blk=vp->dirblk[i];
+#ifdef DEBUG
+		PRINTF_OUT("read dir block %2u: 0x%04x\n",i,blk);
+#endif
+		/* read volume directory block */
+		if (akai_io_blks(vp->partp,addr,
+						 blk,
+						 1,
+						 1,IO_BLKS_READ)<0){ /* 1: alloc cache if possible */
+			return -1;
+		}
+
+		addr+=vp->partp->blksize; /* next */
+	}
+
+	return 0;
+}
+
+	
+	
+int
+akai_write_voldir(struct vol_s *vp,u_int fi)
+{
+	u_int blk0,blk1;
+	u_int blk;
+	u_char *addr;
+
+	if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)||(vp->file==NULL)){
+		return -1;
+	}
+	if ((vp->partp==NULL)||(!vp->partp->valid)||(vp->partp->blksize==0)){
+		return -1;
+	}
+
+	if (fi>=vp->fimax){
+		return -1;
+	}
+
+	/* Note: file entry might overlap two adjacent blocks !!! */
+	/* block(s) for file fi */
+	blk0=fi*sizeof(struct akai_voldir_entry_s);
+	blk1=blk0+sizeof(struct akai_voldir_entry_s)-1;
+	blk0/=vp->partp->blksize;
+	blk1/=vp->partp->blksize;
+	if ((blk0>=VOL_DIRBLKS)||(blk1>=VOL_DIRBLKS)){
+		return -1;
+	}
+
+	/* write volume directory block 0 to partition */
+	blk=vp->dirblk[blk0];
+	/* Note: first file starts at byte 0 in first block */
+	addr=((u_char *)vp->file)+blk0*vp->partp->blksize;
+#ifdef DEBUG
+	PRINTF_OUT("write dir block %2u: 0x%04x\n",blk0,blk);
+#endif
+	if (akai_io_blks(vp->partp,addr,
+					 blk,
+					 1,
+					 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+		return -1;
+	}
+	if (blk1!=blk0){
+		/* write volume directory block 1 to partition */
+		blk=vp->dirblk[blk1];
+		addr+=vp->partp->blksize; /* next */
+#ifdef DEBUG
+		PRINTF_OUT("write dir block %2u: 0x%04x\n",blk1,blk);
+#endif
+		if (akai_io_blks(vp->partp,addr,
+						 blk,
+						 1,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+
+
+/* Note: see comment in akaiutil.h for struct vol_s about copying vol_s!!! */
+void
+akai_copy_structvol(struct vol_s *srcvp,struct vol_s *dstvp)
+{
+
+	if ((srcvp==NULL)||(srcvp->partp==NULL)||(!srcvp->partp->valid)){
+		return;
+	}
+	if (dstvp==NULL){
+		return;
+	}
+
+	/* copy */
+	*dstvp=*srcvp;
+
+	/* fix pointers for copy to be self-contained */
+	if ((srcvp->partp->type==PART_TYPE_FLL)||(srcvp->partp->type==PART_TYPE_FLH)){
+		/* floppy */
+		if ((srcvp->type==AKAI_VOL_TYPE_S3000)||(srcvp->type==AKAI_VOL_TYPE_CD3000)){
+			/* S3000 */
+			/* start of files */
+			dstvp->file=&dstvp->dir.s3000fl.file[0];
+		}
+		/* Note: pointers into floppy header (in partition) remain the same!!! */
+	}else if ((srcvp->partp->type==PART_TYPE_HD9)||(srcvp->partp->type==PART_TYPE_HD)){
+		/* harddisk */
+		if (srcvp->type==AKAI_VOL_TYPE_S900){
+			/* S900 */
+			/* start of files */
+			dstvp->file=&dstvp->dir.s900hd.file[0];
+			/* volume parameters */
+			dstvp->param=NULL; /* S900 has no volume parameters */
+		}else if (srcvp->type==AKAI_VOL_TYPE_S1000){
+			/* S1000 */
+			/* start of files */
+			dstvp->file=&dstvp->dir.s1000hd.file[0];
+			/* volume parameters */
+			dstvp->param=&dstvp->dir.s1000hd.param;
+		}else{
+			/* S3000 */
+			/* start of files */
+			dstvp->file=&dstvp->dir.s3000hd.file[0];
+			/* volume parameters */
+			dstvp->param=&dstvp->dir.s3000hd.param;
+		}
+	}
+}
+
+
+
+/* get volume with index vi */
+/* saves result in *vp */
+int
+akai_get_vol(struct part_s *pp,struct vol_s *vp,u_int vi)
+{
+	u_int i,j;
+	struct akai_flvol_label_s *lp;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type==PART_TYPE_DD){
+		return -1;
+	}
+	if (vp==NULL){
+		return -1;
+	}
+
+	/* in partition */
+	vp->partp=pp;
+
+	if ((pp->type==PART_TYPE_FLL)||(pp->type==PART_TYPE_FLH)){
+		/* S900/S1000/S3000 floppy */
+	
+		/* fake index */
+		if (vi!=0){
+			return -1;
+		}
+		vp->index=vi;
+
+		/* Note: low- and high-density floppy headers are identical */
+		/*       up to first AKAI_FAT_ENTRIES_FLL FAT-entries */
+
+		/* floppy volume label */
+		if (pp->type==PART_TYPE_FLL){
+			lp=&pp->head.fll.label;
+		}else{
+			lp=&pp->head.flh.label;
+		}
+
+		/* load number */
+		vp->lnum=AKAI_VOL_LNUM_OFF;
+
+		/* OS version in floppy header */
+		vp->osver=(lp->osver[1]<<8)+lp->osver[0];
+
+		/* determine floppy volume type */
+		if (pp->head.flh.file[0].type==AKAI_VOLDIR3000FL_FTYPE){ /* S3000 flag? */
+			/* S3000 */
+
+			/* volume type */
+			vp->type=AKAI_VOL_TYPE_S3000;
+
+			/* number of volume directory entries */
+			vp->fimax=AKAI_VOLDIR_ENTRIES_S3000FL;
+			/* start of files */
+			vp->file=&vp->dir.s3000fl.file[0];
+			/* set volume directory blocks */
+			if (pp->type==PART_TYPE_FLL){
+				j=AKAI_VOLDIR3000FLL_BSTART;
+			}else{
+				j=AKAI_VOLDIR3000FLH_BSTART;
+			}
+			for (i=0;i<AKAI_VOLDIR3000FL_BLKS;i++){
+				vp->dirblk[i]=j+i;
+			}
+		}else{
+			/* S900 or S1000 */
+
+			/* determine volume type */
+			if (vp->osver==AKAI_OSVER_S900VOL){
+				/* S900 */
+				vp->type=AKAI_VOL_TYPE_S900;
+			}else{
+				/* S1000 */
+				vp->type=AKAI_VOL_TYPE_S1000;
+			}
+
+			/* number of volume directory entries */
+			vp->fimax=AKAI_VOLDIR_ENTRIES_S1000FL;
+			/* start of files */
+			/* Note: see comment above: start of files is the same for low- and high density */
+			/* Note: S900 and S1000 floppy volume directory is within floppy header */
+			vp->file=&pp->head.flh.file[0]; /* Note: in floppy header */
+			/* set volume directory blocks */
+			if (pp->type==PART_TYPE_FLL){
+				j=AKAI_FLLHEAD_BLKS;
+			}else{
+				j=AKAI_FLHHEAD_BLKS;
+			}
+			for (i=0;i<j;i++){
+				vp->dirblk[i]=i; /* start at offset 0 */
+			}
+		}
+		
+		/* name in floppy header */
+		akai2ascii_name(lp->name,vp->name,vp->type==AKAI_VOL_TYPE_S900);
+		if (vp->name[0]=='\0'){ /* empty volume name? */
+			/* use default volume name as fake volume name */
+			sprintf(vp->name,"VOLUME %03u",vp->index+1);
+		}
+
+		/* volume parameters */
+		if (vp->type==AKAI_VOL_TYPE_S900){
+			/* S900 */
+			vp->param=NULL; /* S900 has no volume parameters */
+		}else{
+			/* S1000 or S3000 */
+			vp->param=&lp->param; /* Note: in floppy header */
+		}
+
+		if (vp->type==AKAI_VOL_TYPE_S3000){
+			/* S3000 */
+			/* read volume directory */
+			if (akai_read_voldir(vp)<0){
+				PRINTF_ERR("volume %u: cannot read volume directory\n",vp->index+1);
+				vp->type=AKAI_VOL_TYPE_INACT; /* XXX mark invalid */
+				return -1;
+			}
+		} /* else: S900 and S1000 floppy volume directory is within floppy header */
+
+		return 0;
+	}
+
+	if (pp->type==PART_TYPE_HD9){
+		/* S900 harddisk */
+
+		/* index */
+		if (vi>=pp->volnummax){
+			return -1;
+		}
+		vp->index=vi;
+
+		/* get volume infos from root directory entry for volume */
+		
+		/* volume type */
+		vp->type=AKAI_VOL_TYPE_S900;
+		
+		/* load number */
+		vp->lnum=AKAI_VOL_LNUM_OFF;
+		
+		/* OS version */
+		/* Note: no floppy volume labels for volumes on harddisk => cannot get OS version */
+		vp->osver=AKAI_OSVER_S900VOL;
+
+		/* name */
+		/* Note: volume names in root directory use S1000/S3000 char conversion */
+		akai2ascii_name(vp->partp->head.hd9.vol[vp->index].name,vp->name,1); /* 1: S900 */
+		if (vp->name[0]=='\0'){ /* empty volume name? */
+			/* use default volume name as fake volume name */
+			sprintf(vp->name,"VOLUME %03u",vp->index+1);
+		}
+
+		/* volume directory block */
+		vp->dirblk[0]=(vp->partp->head.hd9.vol[vp->index].start[1]<<8)
+			+vp->partp->head.hd9.vol[vp->index].start[0];
+		if (vp->dirblk[0]==AKAI_VOL_START_INACT){ /* volume inactive? */
+			vp->type=AKAI_VOL_TYPE_INACT;
+			return -1;
+		}
+		/* check vp->dirblk[0] */
+		if (akai_check_fatblk(vp->dirblk[0],vp->partp->bsize,vp->partp->bsyssize)<0){
+			PRINTF_ERR("volume %u: invalid dir block 0: 0x%04x\n",vp->index+1,vp->dirblk[0]);
+			vp->type=AKAI_VOL_TYPE_INACT; /* XXX mark invalid */
+			return -1;
+		}
+		/* number of volume directory entries */
+		vp->fimax=AKAI_VOLDIR_ENTRIES_S900HD;
+		/* start of files */
+		vp->file=&vp->dir.s900hd.file[0];
+		
+		/* volume parameters */
+		vp->param=NULL; /* S900 has no volume parameters */
+		
+		/* read volume directory */
+		if (akai_read_voldir(vp)<0){
+			PRINTF_ERR("volume %u: cannot read volume directory\n",vp->index+1);
+			vp->type=AKAI_VOL_TYPE_INACT; /* XXX mark invalid */
+			return -1;
+		}
+		
+		return 0;
+	}
+
+	if (pp->type==PART_TYPE_HD){
+		/* S1000/S3000 harddisk sampler partition */
+
+		/* index */
+		if (vi>=pp->volnummax){
+			return -1;
+		}
+		vp->index=vi;
+
+		/* get volume infos from root directory entry for volume */
+		
+		/* volume type */
+		vp->type=vp->partp->head.hd.vol[vp->index].type;
+		
+		/* load number */
+		vp->lnum=vp->partp->head.hd.vol[vp->index].lnum;
+		
+		/* OS version */
+		/* Note: no floppy volume labels for volumes on harddisk => cannot get OS version */
+		/* derive OS version from volume type in root directory entry */
+		if ((vp->type==AKAI_VOL_TYPE_S3000)||(vp->type==AKAI_VOL_TYPE_CD3000)){
+			vp->osver=AKAI_OSVER_S3000MAX; /* XXX */
+		}else{
+			/* XXX assume S1000 */
+			vp->osver=AKAI_OSVER_S1000MAX; /* XXX */
+		}
+
+		/* name */
+		/* Note: volume names in root directory entries use S1000/S3000 char conversion */
+		akai2ascii_name(vp->partp->head.hd.vol[vp->index].name,vp->name,0); /* 0: not S900 */
+		if (vp->name[0]=='\0'){ /* empty volume name? */
+			/* use default volume name as fake volume name */
+			sprintf(vp->name,"VOLUME %03u",vp->index+1);
+		}
+
+		switch (vp->type){
+		case AKAI_VOL_TYPE_INACT:
+			return -1; /* invalid */
+		case AKAI_VOL_TYPE_S1000:
+		case AKAI_VOL_TYPE_S3000:
+		case AKAI_VOL_TYPE_CD3000:
+			break;
+		default:
+#if 0
+			/* XXX assume S1000 */
+			vp->type=AKAI_VOL_TYPE_S1000;
+			break;
+#else
+			PRINTF_ERR("volume %u: unknown volume type (0x%04x)\n",vp->index+1,vp->type);
+			vp->type=AKAI_VOL_TYPE_INACT; /* XXX mark inactive */
+			return -1;
+#endif
+		}
+		
+		/* volume directory block(s) */
+		vp->dirblk[0]=(vp->partp->head.hd.vol[vp->index].start[1]<<8)
+			+vp->partp->head.hd.vol[vp->index].start[0];
+		/* check vp->dirblk[0] */
+		if (akai_check_fatblk(vp->dirblk[0],vp->partp->bsize,vp->partp->bsyssize)<0){
+			PRINTF_ERR("volume %u: invalid dir block 0: 0x%04x\n",vp->index+1,vp->dirblk[0]);
+			vp->type=AKAI_VOL_TYPE_INACT; /* XXX mark invalid */
+			return -1;
+		}
+		/* volume directory entries */
+		if (vp->type==AKAI_VOL_TYPE_S1000){
+			/* S1000 */
+			/* number of volume directory entries */
+			vp->fimax=AKAI_VOLDIR_ENTRIES_S1000HD;
+			/* start of files */
+			vp->file=&vp->dir.s1000hd.file[0];
+		}else{
+			/* should be S3000 */
+			vp->dirblk[1]=(vp->partp->fat[vp->dirblk[0]][1]<<8)
+				+vp->partp->fat[vp->dirblk[0]][0];
+			/* check vp->dirblk[1] */
+			if (akai_check_fatblk(vp->dirblk[1],vp->partp->bsize,vp->partp->bsyssize)<0){ /* block 1 not found? */
+				/* Note: S3000 format should always have block 1 */
+#if 1
+				PRINTF_ERR("volume %u: S3000 volume directory block 1 missing, assuming S1000 volume\n",vp->index+1);
+				/* XXX assume S1000 */
+				vp->type=AKAI_VOL_TYPE_S1000;
+				/* number of volume directory entries */
+				vp->fimax=AKAI_VOLDIR_ENTRIES_S1000HD;
+				/* start of files */
+				vp->file=&vp->dir.s1000hd.file[0];
+#else
+				PRINTF_ERR("volume %u: S3000 volume directory block 1 missing\n",vp->index+1);
+				vp->type=AKAI_VOL_TYPE_INACT; /* XXX mark invalid */
+				return -1;
+#endif
+			}else{
+				/* S3000 */
+				/* vp->dirblk[1] should be volume directory block 1 now */
+				/* number of volume directory entries */
+				vp->fimax=AKAI_VOLDIR_ENTRIES_S3000HD; /* block 0 and 1 */
+				/* start of files */
+				vp->file=&vp->dir.s3000hd.file[0];
+			}
+		}
+		
+		/* volume parameters */
+		if (vp->type==AKAI_VOL_TYPE_S1000){
+			/* S1000 harddisk */
+			vp->param=&vp->dir.s1000hd.param;
+		}else{
+			/* S3000 harddisk */
+			vp->param=&vp->dir.s3000hd.param;
+		}
+		
+		/* read volume directory */
+		if (akai_read_voldir(vp)<0){
+			PRINTF_ERR("volume %u: cannot read volume directory\n",vp->index+1);
+			vp->type=AKAI_VOL_TYPE_INACT; /* XXX mark invalid */
+			return -1;
+		}
+		
+		return 0;
+	}
+
+	return -1;
+}
+
+
+
+/* find first volume with given name */
+/* saves result in *vp */
+int
+akai_find_vol(struct part_s *pp,struct vol_s *vp,char *name)
+{
+	u_int osver;
+	u_int vi;
+	u_int ai,aivifound;
+	char namebuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	char vnamebuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	u_int i,j,l;
+
+	if ((pp==NULL)||(!pp->valid)){
+		return -1;
+	}
+	if (pp->type==PART_TYPE_DD){
+		return -1;
+	}
+	if (vp==NULL){
+		return -1;
+	}
+	if (name==NULL){
+		return -1;
+	}
+
+	/* fix name */
+	l=(u_int)strlen(name);
+	if (l>AKAI_NAME_LEN){ /* too long for namebuf? */
+		return -1;
+	}
+	for (i=0;i<l;i++){
+		if (name[i]=='_'){ /* for keyboard entry */
+			namebuf[i]=' ';
+		}else{
+			namebuf[i]=name[i];
+		}
+	}
+	namebuf[i]='\0';
+	/* remove trailing ' ' (XXX don't care how many) */
+	for (i=0;i<l;i++){
+		if (namebuf[l-i-1]==' '){
+			namebuf[l-i-1]='\0';
+		}else{
+			break;
+		}
+	}
+
+	/* volumes in partition */
+	aivifound=pp->volnummax; /* invalid */
+	ai=0;
+	for (vi=0;vi<pp->volnummax;vi++){
+		if (pp->type==PART_TYPE_FLL){
+			/* OS version in floppy header */
+			osver=(pp->head.fll.label.osver[1]<<8)+pp->head.fll.label.osver[0];
+			/* volume name in floppy header */
+			akai2ascii_name(pp->head.fll.label.name,vnamebuf,osver==AKAI_OSVER_S900VOL);
+		}else if (pp->type==PART_TYPE_FLH){
+			/* OS version in floppy header */
+			osver=(pp->head.flh.label.osver[1]<<8)+pp->head.flh.label.osver[0];
+			/* volume name in floppy header */
+			akai2ascii_name(pp->head.flh.label.name,vnamebuf,osver==AKAI_OSVER_S900VOL);
+		}else if (pp->type==PART_TYPE_HD9){
+			/* S900 harddisk */
+			j=vp->dirblk[0]=(pp->head.hd9.vol[vi].start[1]<<8)
+				+pp->head.hd9.vol[vi].start[0];
+			if (j==AKAI_VOL_START_INACT){ /* inactive? */
+				continue; /* next */
+			}
+			/* volume name in root directory entry */
+			akai2ascii_name(pp->head.hd9.vol[vi].name,vnamebuf,1); /* 1: S900 */
+		}else if (pp->type==PART_TYPE_HD){
+			/* S1000/S3000 harddisk sampler partition */
+			if (pp->head.hd.vol[vi].type==AKAI_VOL_TYPE_INACT){ /* inactive? */
+				continue; /* next */
+			}
+			/* volume name in root directory */
+			akai2ascii_name(pp->head.hd.vol[vi].name,vnamebuf,0); /* 0: not S900 */
+		}else{
+			continue; /* next */
+		}
+		ai++;
+
+		if (vnamebuf[0]=='\0'){ /* empty volume name? */
+			/* use default volume name as fake volume name */
+			sprintf(vnamebuf,"VOLUME %03u",vi+1);
+		}
+
+		/* compare name (case-insensitive) */
+		if (strcasecmp(vnamebuf,namebuf)==0){ /* match? */
+			break; /* found */
+		}
+
+		if ((pp->type==PART_TYPE_HD9)&&(aivifound>=pp->volnummax)){ /* S900 harddisk and no alias name match yet? */
+			/* alias name for volume on S900 harddisk */
+			sprintf(vnamebuf,"V%u",ai);
+			/* compare name (case-insensitive) */
+			if (strcasecmp(vnamebuf,namebuf)==0){ /* match? */
+				/* Note: name match takes precendence over alias name match */
+				aivifound=vi; /* save for later */
+			}
+		}
+	}
+	if (vi==pp->volnummax){ /* no name match? */
+		if ((pp->type==PART_TYPE_HD9)&&(aivifound<pp->volnummax)){ /* S900 harddisk and alias name match? */
+			vi=aivifound;
+		}else{
+			return -1;
+		}
+	}
+
+	/* get volume */
+	return akai_get_vol(pp,vp,vi);
+}
+
+
+
+int
+akai_rename_vol(struct vol_s *vp,char *name,u_int lnum,u_int osver,struct akai_volparam_s *parp)
+{
+	int modflag;
+	u_int blk;
+	u_char *addr;
+	struct akai_flvol_label_s *lp;
+	u_int hdsiz;
+
+	if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)){
+		return -1;
+	}
+	if ((vp->partp==NULL)||(!vp->partp->valid)){
+		return -1;
+	}
+
+	if ((vp->partp->type==PART_TYPE_FLL)||(vp->partp->type==PART_TYPE_FLH)){
+		/* floppy */
+
+		modflag=0; /* floppy header not modified yet */
+
+		/* floppy volume label */
+		if (vp->partp->type==PART_TYPE_FLL){
+			lp=&vp->partp->head.fll.label;
+			hdsiz=AKAI_FLLHEAD_BLKS;
+		}else{
+			lp=&vp->partp->head.flh.label;
+			hdsiz=AKAI_FLHHEAD_BLKS;
+		}
+
+		/* Note: no load number on floppy */
+
+		/* Note: cannot switch volume type S900/S1000/S3000 */
+		if (vp->type==AKAI_VOL_TYPE_S900){
+			/* S900 floppy */
+			/* correct OS version if necessary */
+			osver=AKAI_OSVER_S900VOL;
+			if (osver!=vp->osver){ /* need to modify? */
+				vp->osver=osver;
+				/* Note: S900 has no floppy volume label, all zero */
+				bzero(lp,sizeof(struct akai_flvol_label_s));
+				modflag=1;
+			}
+		}else{
+			/* S1000/S300 floppy */
+			/* correct OS version if necessary */
+			if (vp->type==AKAI_VOL_TYPE_S1000){
+				/* S1000 floppy */
+				if ((osver==AKAI_OSVER_S900VOL)||(osver>AKAI_OSVER_S1100MAX)){
+					osver=AKAI_OSVER_S1000MAX; /* XXX */
+				}
+			}else{
+				/* S3000 floppy */
+				if ((osver==AKAI_OSVER_S900VOL)||(osver>AKAI_OSVER_S3000MAX)){
+					osver=AKAI_OSVER_S3000MAX; /* XXX */
+				}
+			}
+			/* OS version */
+			if (osver!=vp->osver){ /* new OS version? */
+				vp->osver=osver;
+				lp->osver[1]=0xff&(osver>>8);
+				lp->osver[0]=0xff&osver;
+				modflag=1;
+			}
+
+			/* name */
+			if (name!=NULL){ /* new name? */
+				if (strlen(name)>(u_int)AKAI_NAME_LEN){
+					PRINTF_ERR("invalid name length\n");
+					return -1;
+				}
+				if (name!=vp->name){ /* not already in vp->name? */
+					/* copy */
+					strcpy(vp->name,name); /* Note: name has been checked above */
+				}
+				ascii2akai_name(name,lp->name,0); /* 0: not S900 */
+				modflag=1;
+			}
+
+			/* volume parameters */
+			if ((parp!=NULL)&&(vp->param!=NULL)){ /* new volume parameters? */
+				if (parp!=vp->param){ /* not already vp->param? */
+					/* copy */
+					bcopy(parp,vp->param,sizeof(struct akai_volparam_s));
+				} /* else: vp->param[] possibly modified */
+				modflag=1;
+			}
+		}
+
+		if (modflag){
+			/* write floppy header */
+			if (akai_io_blks(vp->partp,(u_char *)&vp->partp->head.flh,
+							 0,
+							 hdsiz,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}
+		
+		return 0;
+	}
+	
+	if (vp->partp->type==PART_TYPE_HD9){
+		/* S900 harddisk */
+
+		/* set vol_s */
+		modflag=0; /* root directory not modified yet */
+		
+		/* Note: no load number on S900 harddisk */
+
+		/* correct type and OS version */
+		vp->type=AKAI_VOL_TYPE_S900;
+		vp->osver=AKAI_OSVER_S900VOL;
+		/* Note: no floppy volume labels for volumes on harddisk => cannot save OS version */
+
+		/* name */
+		if (name!=NULL){
+			if (strlen(name)>AKAI_NAME_LEN_S900){
+				PRINTF_ERR("invalid name length\n");
+				return -1;
+			}
+			if (name!=vp->name){ /* not already in vp->name? */
+				/* copy */
+				strcpy(vp->name,name); /* Note: name has been checked above */
+			}
+			/* change root directory entry in partition */
+			ascii2akai_name(name,vp->partp->head.hd9.vol[vp->index].name,1); /* 1: S900 */
+			modflag=1;
+		}
+		
+		if (modflag){
+			/* write new root directory to partition */
+			/* copy first FAT entries */
+			bcopy((u_char *)&vp->partp->head.hd9.fatblk,(u_char *)&vp->partp->head.hd9.fatblk0,AKAI_HD9FAT0_ENTRIES*2);
+			/* write harddisk header */
+			if (akai_io_blks(vp->partp,(u_char *)&vp->partp->head.hd9,
+							 0,
+							 AKAI_HD9HEAD_BLKS,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}
+		
+		/* Note: no volume parameters on S900 harddisk */
+		
+		return 0;
+	}
+
+	if (vp->partp->type==PART_TYPE_HD){
+		/* S1000/S3000 harddisk sampler partition */
+
+		/* set vol_s */
+		modflag=0; /* root directory not modified yet */
+		
+		/* load number */
+		if (lnum!=vp->lnum){ /* need to modify? */
+			if ((lnum!=AKAI_VOL_LNUM_OFF)
+				&&((lnum<AKAI_VOL_LNUM_MIN)||(lnum>AKAI_VOL_LNUM_MAX))){
+				return -1;
+			}
+			vp->lnum=lnum;
+			/* change root directory entry in partition */
+			vp->partp->head.hd.vol[vp->index].lnum=lnum;
+			modflag=1;
+		}
+
+		/* correct type and OS version */
+		if ((vp->type==AKAI_VOL_TYPE_S900)||(vp->osver==AKAI_OSVER_S900VOL)){ /* incorrect for partition type? */
+			vp->type=AKAI_VOL_TYPE_S1000; /* XXX */
+			vp->osver=AKAI_OSVER_S1000MAX; /* XXX */
+		}
+		/* Note: no floppy volume labels for volumes on harddisk => cannot save OS version */
+
+		/* name */
+		if (name!=NULL){
+			if (strlen(name)>AKAI_NAME_LEN){
+				PRINTF_ERR("invalid name length\n");
+				return -1;
+			}
+			if (name!=vp->name){ /* not already in vp->name? */
+				/* copy */
+				strcpy(vp->name,name); /* Note: name has been checked above */
+			}
+			/* change root directory entry in partition */
+			ascii2akai_name(name,vp->partp->head.hd.vol[vp->index].name,0); /* 0: not S900 */
+			modflag=1;
+		}
+		
+		if (modflag){
+			/* write new root directory to partition */
+			/* write partition header */
+			if (akai_io_blks(vp->partp,(u_char *)&vp->partp->head.hd,
+							 0,
+							 AKAI_PARTHEAD_BLKS,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}
+		
+		/* volume parameters */
+		if ((parp!=NULL)&&(vp->param!=NULL)){
+			if (parp!=vp->param){ /* not already vp->param? */
+				/* copy */
+				bcopy(parp,vp->param,sizeof(struct akai_volparam_s));
+			} /* else: vp->param[] possibly modified */
+			
+			/* get volume directory block of volume parameters */
+			if ((vp->type==AKAI_VOL_TYPE_S3000)||(vp->type==AKAI_VOL_TYPE_CD3000)){
+				blk=vp->dirblk[1];
+				addr=((u_char *)&vp->dir)+AKAI_HD_BLOCKSIZE;
+			}else{
+				blk=vp->dirblk[0];
+				addr=(u_char *)&vp->dir;
+			}
+			
+			/* write new volume directory block to partition */
+			if (akai_io_blks(vp->partp,addr,
+							 blk,
+							 1,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}
+		
+		return 0;
+	}
+
+	return -1;
+}
+
+
+
+/* uses *vp as output */
+int
+akai_create_vol(struct part_s *pp,struct vol_s *vp,u_int type,u_int index,char *name,u_int lnum,struct akai_volparam_s *parp)
+{
+	u_char *addr;
+	u_int i,j;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (vp==NULL){
+		return -1;
+	}
+
+	if ((pp->type!=PART_TYPE_HD9)&&(pp->type!=PART_TYPE_HD)){
+		PRINTF_ERR("cannot create additional volume for this partition type\n");
+		return -1;
+	}
+	/* now, harddisk */
+
+	/* partition */
+	vp->partp=pp;
+
+	/* type */
+	if (pp->type==PART_TYPE_HD9){
+		/* S900 */
+		if (type!=AKAI_VOL_TYPE_S900){
+			PRINTF_ERR("cannot create this volume type for this partition type\n");
+			return -1;
+		}
+	}else if (pp->type==PART_TYPE_HD){
+		/* S1000/S3000 */
+		if ((type!=AKAI_VOL_TYPE_S1000)&&(type!=AKAI_VOL_TYPE_S3000)&&(type!=AKAI_VOL_TYPE_CD3000)){
+			PRINTF_ERR("cannot create this volume type for this partition type\n");
+			return -1;
+		}
+	}
+	vp->type=type;
+
+	/* load number */
+	if (pp->type==PART_TYPE_HD9){
+		/* S900 */
+		vp->lnum=AKAI_VOL_LNUM_OFF;
+	}else{
+		/* S1000/S3000 */
+		if ((lnum!=AKAI_VOL_LNUM_OFF)
+			&&((lnum<AKAI_VOL_LNUM_MIN)||(lnum>AKAI_VOL_LNUM_MAX))){
+			return -1;
+		}
+		vp->lnum=lnum;
+	}
+
+	/* OS version */
+	if (vp->type==AKAI_VOL_TYPE_S900){
+		/* S900 */
+		vp->osver=AKAI_OSVER_S900VOL;
+	}else if (vp->type==AKAI_VOL_TYPE_S1000){
+		/* S1000 */
+		vp->osver=AKAI_OSVER_S1000MAX; /* XXX */
+	}else{
+		/* S3000 */
+		vp->osver=AKAI_OSVER_S3000MAX; /* XXX */
+	}
+
+	/* name */
+	if ((name!=NULL)&&(name[0]!='\0')){ /* volume name given? */
+		if (strlen(name)>(u_int)((vp->type==AKAI_VOL_TYPE_S900)?AKAI_NAME_LEN_S900:AKAI_NAME_LEN)){
+			PRINTF_ERR("invalid name length\n");
+			return -1;
+		}
+		strcpy(vp->name,name);
+	}
+
+	/* index */
+	if (index==AKAI_CREATE_VOL_NOINDEX){ /* no user-supplied volume index? */
+		/* find inactive entry in root directory in partition */
+		for (i=0;i<pp->volnummax;i++){
+			if (pp->type==PART_TYPE_HD9){
+				/* S900 */
+				j=vp->dirblk[0]=(vp->partp->head.hd9.vol[i].start[1]<<8)
+					+vp->partp->head.hd9.vol[i].start[0];
+				if (j==AKAI_VOL_START_INACT){ /* inactive? */
+					/* index */
+					vp->index=i;
+					break; /* found one */
+				}
+			}else{
+				/* S1000/S3000 */
+				if (vp->partp->head.hd.vol[i].type==AKAI_VOL_TYPE_INACT){ /* inactive? */
+					/* index */
+					vp->index=i;
+					break; /* found one */
+				}
+			}
+		}
+		if (i==pp->volnummax){ /* none found? */
+			PRINTF_OUT("no inactive volume found");
+			return -1;
+		}
+	}else{
+		/* user-supplied index */
+		if (index>=pp->volnummax){
+			return -1;
+		}
+		if (pp->type==PART_TYPE_HD9){
+			/* S900 */
+			j=vp->dirblk[0]=(vp->partp->head.hd9.vol[index].start[1]<<8)
+				+vp->partp->head.hd9.vol[index].start[0];
+			if (j!=AKAI_VOL_START_INACT){ /* not inactive? */
+				PRINTF_OUT("volume not inactive\n");
+				return -1;
+			}
+		}else{
+			/* S1000/S3000 */
+			if (vp->partp->head.hd.vol[index].type!=AKAI_VOL_TYPE_INACT){ /* not inactive? */
+				PRINTF_OUT("volume not inactive\n");
+				return -1;
+			}
+		}
+		/* index */
+		vp->index=index;
+	}
+
+	if ((name==NULL)||(name[0]=='\0')){ /* no volume name given? */
+		/* default volume name */
+		sprintf(vp->name,"VOLUME %03u",vp->index+1);
+	}
+
+	/* allocate volume directory */
+	if (vp->type==AKAI_VOL_TYPE_S900){
+		/* S900 */
+		if (akai_allocate_fatchain(vp->partp,
+									AKAI_VOLDIR900HD_BLKS,
+									&vp->dirblk[0],
+									AKAI_VOLDIR900HD_BLKS,
+									AKAI_FAT_CODE_DIREND900HD)<0){ /* end code */
+			return -1;
+		}
+		/* number of volume directory entries */
+		vp->fimax=AKAI_VOLDIR_ENTRIES_S900HD;
+		/* start of files */
+		vp->file=&vp->dir.s900hd.file[0];
+	}else if (vp->type==AKAI_VOL_TYPE_S1000){
+		/* S1000 */
+		if (akai_allocate_fatchain(vp->partp,
+									AKAI_VOLDIR1000HD_BLKS,
+									&vp->dirblk[0],
+									AKAI_VOLDIR1000HD_BLKS,
+									AKAI_FAT_CODE_DIREND1000HD)<0){ /* end code */
+									return -1;
+		}
+		/* number of volume directory entries */
+		vp->fimax=AKAI_VOLDIR_ENTRIES_S1000HD;
+		/* start of files */
+		vp->file=&vp->dir.s1000hd.file[0];
+	}else{
+		/* S3000 */
+		if (akai_allocate_fatchain(vp->partp,
+									AKAI_VOLDIR3000HD_BLKS,
+									&vp->dirblk[0],
+									AKAI_VOLDIR3000HD_BLKS, /* XXX want contiguous blocks */
+									AKAI_FAT_CODE_DIREND3000)<0){ /* end code */
+			return -1;
+		}
+		/* number of volume directory entries */
+		vp->fimax=AKAI_VOLDIR_ENTRIES_S3000HD;
+		/* start of files */
+		vp->file=&vp->dir.s3000hd.file[0];
+	}
+
+	/* initialize volume directory */
+	bzero(&vp->dir,sizeof(union akai_voldir_u));
+	for (i=0;i<vp->fimax;i++){
+		vp->file[i].type=AKAI_FTYPE_FREE;
+	}
+
+	/* volume parameters */
+	if (vp->type==AKAI_VOL_TYPE_S900){
+		/* S900 */
+		vp->param=NULL; /* S900 has no volume paramaters */
+	}else if (vp->type==AKAI_VOL_TYPE_S1000){
+		/* S1000 */
+		vp->param=&vp->dir.s1000hd.param;
+	}else{
+		/* S3000 */
+		vp->param=&vp->dir.s3000hd.param;
+	}
+	if (vp->param!=NULL){
+		if (parp!=NULL){
+			/* copy volume parameters */
+			bcopy(parp,vp->param,sizeof(struct akai_volparam_s));
+		}else{
+			/* default volume parameters */
+			akai_init_volparam(vp->param,(vp->type==AKAI_VOL_TYPE_S3000)||(vp->type==AKAI_VOL_TYPE_CD3000));
+		}
+	}
+
+	/* write new volume directory block 0 to partition */
+	addr=(u_char *)&vp->dir;
+	if (akai_io_blks(vp->partp,addr,
+					 vp->dirblk[0],
+					 1,
+					 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+		return -1;
+	}
+
+	if (vp->fimax>AKAI_VOLDIR_ENTRIES_1BLKHD){ /* second volume directory block? */
+		/* block 1 from FAT */
+		vp->dirblk[1]=(vp->partp->fat[vp->dirblk[0]][1]<<8)
+					  +vp->partp->fat[vp->dirblk[0]][0];
+		/* write new volume directory block 1 to partition */
+		addr+=AKAI_HD_BLOCKSIZE;
+		if (akai_io_blks(vp->partp,addr,
+						 vp->dirblk[1],
+						 1,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			return -1;
+		}
+	}
+
+	/* update root directory entry in partition */
+	if (pp->type==PART_TYPE_HD9){
+		/* S900 */
+		/* Note: no OS version nor load number on S900 harddisk */
+		ascii2akai_name(vp->name,vp->partp->head.hd9.vol[vp->index].name,1); /* 1: S900 */
+		/* start */
+		vp->partp->head.hd9.vol[vp->index].start[1]=0xff&(vp->dirblk[0]>>8);
+		vp->partp->head.hd9.vol[vp->index].start[0]=0xff&vp->dirblk[0];
+
+		/* write new root directory to harddisk */
+		/* copy first FAT entries */
+		bcopy((u_char *)&vp->partp->head.hd9.fatblk,(u_char *)&vp->partp->head.hd9.fatblk0,AKAI_HD9FAT0_ENTRIES*2);
+		/* write harddisk header */
+		if (akai_io_blks(vp->partp,(u_char *)&vp->partp->head.hd9,
+						 0,
+						 AKAI_HD9HEAD_BLKS,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			return -1;
+		}
+	}else{
+		/* S1000/S3000 */
+		vp->partp->head.hd.vol[vp->index].type=(u_char)vp->type;
+		/* Note: no floppy volume labels for volumes on harddisk => cannot write OS version */
+		/*       akai_get_vol() will derive OS version from volume type in root directory entry */
+		vp->partp->head.hd.vol[vp->index].lnum=(u_char)vp->lnum;
+		ascii2akai_name(vp->name,vp->partp->head.hd.vol[vp->index].name,0); /* 0: not S900 */
+		/* start */
+		vp->partp->head.hd.vol[vp->index].start[1]=0xff&(vp->dirblk[0]>>8);
+		vp->partp->head.hd.vol[vp->index].start[0]=0xff&vp->dirblk[0];
+
+		/* write new root directory to partition */
+		/* write partition header */
+		if (akai_io_blks(vp->partp,(u_char *)&vp->partp->head.hd,
+						 0,
+						 AKAI_PARTHEAD_BLKS,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+
+
+int
+akai_wipe_vol(struct vol_s *vp,int delflag)
+{
+	u_int fi;
+	struct file_s tmpfile;
+
+	if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)){
+		return -1;
+	}
+	if ((vp->partp==NULL)||(!vp->partp->valid)||(vp->partp->fat==NULL)){
+		return -1;
+	}
+
+	if (delflag&&(vp->partp->type!=PART_TYPE_HD9)&&(vp->partp->type!=PART_TYPE_HD)){
+		PRINTF_ERR("cannot remove floppy volume\n");
+		return -1;
+	}
+
+	/* delete all files in volume */
+	for (fi=0;fi<vp->fimax;fi++){
+		if (akai_get_file(vp,&tmpfile,fi)<0){
+			continue; /* next file */
+		}
+		if (akai_delete_file(&tmpfile)<0){
+			return -1;
+		}
+	}
+
+	if (delflag){
+		/* now, harddisk */
+
+		/* free FAT block(s) of volume */
+		vp->partp->fat[vp->dirblk[0]][1]=0xff&(AKAI_FAT_CODE_FREE>>8);
+		vp->partp->fat[vp->dirblk[0]][0]=0xff&AKAI_FAT_CODE_FREE;
+		if ((vp->fimax>AKAI_VOLDIR_ENTRIES_1BLKHD)
+			&&(akai_check_fatblk(vp->dirblk[1],vp->partp->bsize,vp->partp->bsyssize)==0)){ /* also block 1? */
+			vp->partp->fat[vp->dirblk[1]][1]=0xff&(AKAI_FAT_CODE_FREE>>8);
+			vp->partp->fat[vp->dirblk[1]][0]=0xff&AKAI_FAT_CODE_FREE;
+		}
+		/* Note: free and bad block counter will be updated below */
+
+		/* free root directory entry in partition */
+		if (vp->partp->type==PART_TYPE_HD9){
+			/* S900 */
+			vp->partp->head.hd9.vol[vp->index].start[1]=0xff&(AKAI_VOL_START_INACT>>8);
+			vp->partp->head.hd9.vol[vp->index].start[0]=0xff&AKAI_VOL_START_INACT;
+			/* XXX keep name */
+
+			/* write new FAT and root directory to partition */
+			/* copy first FAT entries */
+			bcopy((u_char *)&vp->partp->head.hd9.fatblk,(u_char *)&vp->partp->head.hd9.fatblk0,AKAI_HD9FAT0_ENTRIES*2);
+			/* write harddisk header */
+			if (akai_io_blks(vp->partp,(u_char *)&vp->partp->head.hd9,
+							 0,
+							 AKAI_HD9HEAD_BLKS,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}else{
+			/* S1000/S3000 */
+			vp->partp->head.hd.vol[vp->index].type=AKAI_VOL_TYPE_INACT;
+			/* XXX keep name etc. */
+
+			/* write new FAT and root directory to partition */
+			/* write partition header */
+			if (akai_io_blks(vp->partp,(u_char *)&vp->partp->head.hd,
+							 0,
+							 AKAI_PARTHEAD_BLKS,
+							 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+				return -1;
+			}
+		}
+	}
+
+	/* count free and bad blocks */
+	akai_countfree_part(vp->partp);
+
+	/* Note: no need to exit or restart now */
+	return 0;
+}
+
+
+
+void
+akai_list_volparam(struct akai_volparam_s *parp,int listflag)
+{
+	u_int i;
+
+	if (parp==NULL){
+		return;
+	}
+
+	if (listflag){
+		PRINTF_OUT("volume parameters:\nidx   val\n---------\n");
+		for (i=0;i<sizeof(struct akai_volparam_s);i++){
+			/* XXX */
+			PRINTF_OUT("%3u  0x%02x",i,(u_int)((u_char *)parp)[i]);
+			switch (i){
+			case 0:
+				PRINTF_OUT("  (program select MIDI channel-1)\n");
+				break;
+			case 1:
+				PRINTF_OUT("  (MIDI OMNI for program select)\n");
+				break;
+			case 2:
+				PRINTF_OUT("  (program select enable)\n");
+				break;
+			case 3:
+				PRINTF_OUT("  (selected program number-1)\n");
+				break;
+			case 4:
+				PRINTF_OUT("  (MIDI OMNI override for play input)\n");
+				break;
+			case 5:
+				PRINTF_OUT("  (MIDI system exclusive channel-1)\n");
+				break;
+			default:
+				PRINTF_OUT("\n");
+				break;
+			}
+		}
+		PRINTF_OUT("---------\n\n");
+	}
+
+	PRINTF_OUT("volume parameters:\n");
+	PRINTF_OUT("program select MIDI channel:       %u\n",((u_int)parp->progselmidich1)+1);
+	PRINTF_OUT("MIDI OMNI for program select:      %s\n",parp->progselomni?"ON":"OFF");
+	PRINTF_OUT("program select enable:             %s\n",parp->progselenab?"ON":"OFF");
+	PRINTF_OUT("selected program number:           %u\n",((u_int)parp->prognr1)+1);
+	PRINTF_OUT("MIDI OMNI override for play input: %s\n",parp->playinominovrr?"ON":"OFF");
+	PRINTF_OUT("MIDI system exclusive channel:     %u\n",((u_int)parp->sysexch1)+1);
+}
+
+void
+akai_init_volparam(struct akai_volparam_s *parp,int s3000flag)
+{
+
+	if (parp==NULL){
+		return;
+	}
+
+	/* default volume parameters */
+	bzero(parp,sizeof(struct akai_volparam_s));
+	if (s3000flag){
+		/* S3000 */
+		parp->progselomni=0x01; /* XXX */
+		parp->progselenab=0x01; /* XXX */
+		parp->dummy1[0]=0x32; /* XXX */
+		parp->dummy1[1]=0x09; /* XXX */
+		parp->dummy1[2]=0x0c; /* XXX */
+		parp->dummy1[3]=0xff; /* XXX */
+	}else{
+		/* S1000 */
+		parp->progselomni=0x01; /* XXX */
+		parp->progselenab=0x01; /* XXX */
+	}
+}
+
+
+
+void
+akai_print_lnum(u_int lnum)
+{
+
+	if (lnum==AKAI_VOL_LNUM_OFF){
+		PRINTF_OUT("-  ");
+	}else{
+		PRINTF_OUT("%03u",lnum);
+	}
+}
+
+u_int
+akai_get_lnum(char *name)
+{
+	u_int lnum;
+
+	if (name==NULL){
+		return AKAI_VOL_LNUM_OFF;
+	}
+
+	if (strcasecmp(name,"OFF")==0){
+		return AKAI_VOL_LNUM_OFF;
+	}
+
+	lnum=(u_int)atoi(name);
+	if ((lnum<AKAI_VOL_LNUM_MIN)||(lnum>AKAI_VOL_LNUM_MAX)){
+		PRINTF_ERR("invalid load number, setting OFF\n");
+		return AKAI_VOL_LNUM_OFF;
+	}
+
+	return lnum;
+}
+
+
+
+void
+akai_list_tags(struct part_s *pp)
+{
+	u_int i;
+	char namebuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+
+	if ((pp==NULL)||(!pp->valid)){
+		return;
+	}
+
+	if (pp->type!=PART_TYPE_HD){
+		PRINTF_OUT("no tags in this partition type\n");
+		return;
+	}
+	/* now, S1000/S3000 harddisk sampler partition */
+
+	/* check magic */
+	if (strncmp(AKAI_PARTHEAD_TAGSMAGIC,(char *)pp->head.hd.tagsmagic,4)!=0){
+		PRINTF_OUT("no tags present\n");
+		return;
+	}
+
+	PRINTF_OUT("tag  name\n");
+	PRINTF_OUT("-----------------\n");
+	for (i=0;i<AKAI_PARTHEAD_TAGNUM;i++){
+		/* Note: tag names use S1000/S3000 char conversion */
+		akai2ascii_name(pp->head.hd.tag[i],namebuf,0); /* 0: not S900 */
+		PRINTF_OUT(" %02u  %s\n",i+1,namebuf); /* XXX default tag name */
+	}
+	PRINTF_OUT("-----------------\n");
+}
+
+
+
+int
+akai_rename_tag(struct part_s *pp,char *name,u_int ti,int wipeflag)
+{
+	u_int i;
+	char namebuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+
+	if ((pp==NULL)||(!pp->valid)){
+		return -1;
+	}
+
+	if (pp->type!=PART_TYPE_HD){
+		PRINTF_OUT("no tags in this partition type\n");
+		return -1;
+	}
+	/* now, S1000/S3000 harddisk sampler partition */
+
+	if (name!=NULL){
+		if ((strlen(name)>AKAI_NAME_LEN)||(ti>=AKAI_PARTHEAD_TAGNUM)){
+			return -1;
+		}
+	}
+
+	if (wipeflag){
+		bcopy(AKAI_PARTHEAD_TAGSMAGIC,pp->head.hd.tagsmagic,4); /* magic */
+		for (i=0;i<AKAI_PARTHEAD_TAGNUM;i++){
+			sprintf(namebuf,"TAG %c       ",(char)('A'+i)); /* XXX default tag name */
+			/* Note: tag names use S1000/S3000 char conversion */
+			ascii2akai_name(namebuf,pp->head.hd.tag[i],0); /* 0: not S900 */
+		}
+	}
+
+	if (name!=NULL){
+		/* check magic */
+		if (strncmp(AKAI_PARTHEAD_TAGSMAGIC,(char *)pp->head.hd.tagsmagic,4)!=0){
+			PRINTF_OUT("no tags present\n");
+			return -1;
+		}
+
+		/* set tag */
+		/* Note: tag names use S1000/S3000 char conversion */
+		ascii2akai_name(name,pp->head.hd.tag[ti],0); /* 0: not S900 */
+	}
+
+	/* write new tag(s) to partition */
+	/* write partition header */
+	return akai_io_blks(pp,(u_char *)&pp->head.hd,
+						0,
+						AKAI_PARTHEAD_BLKS,
+						1,IO_BLKS_WRITE); /* 1: allocate cache if possible */
+}
+
+
+
+int
+copy_tags(struct part_s *srcpp,struct part_s *dstpp)
+{
+
+	if ((srcpp==NULL)||(!srcpp->valid)){
+		return -1;
+	}
+	if ((dstpp==NULL)||(!dstpp->valid)){
+		return -1;
+	}
+
+	if ((srcpp->type!=PART_TYPE_HD)||(dstpp->type!=PART_TYPE_HD)){
+		PRINTF_OUT("no tags in this partition type\n");
+		return -1;
+	}
+	/* now, S1000/S3000 harddisk sampler partition */
+
+	/* copy tags */
+	bcopy(srcpp->head.hd.tagsmagic,dstpp->head.hd.tagsmagic,4); /* magic */
+	bcopy(srcpp->head.hd.tag[0],dstpp->head.hd.tag[0],
+		AKAI_PARTHEAD_TAGNUM*AKAI_NAME_LEN); /* tag names */
+
+	/* write new tag(s) to partition */
+	/* write partition header */
+	return akai_io_blks(dstpp,(u_char *)&dstpp->head.hd,
+						0,
+						AKAI_PARTHEAD_BLKS,
+						1,IO_BLKS_WRITE);/* 1: allocate cache if possible */
+}
+
+
+
+void
+akai_print_cdinfo(struct part_s *pp,int verbose)
+{
+	u_int c;
+	u_int i;
+	u_int fnum;
+	u_int bn;
+	char namebuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	char fnamebuf[AKAI_NAME_LEN+4+1]; /* name (ASCII), +4 for ".<type>", +1 for '\0' */
+	u_char buf[AKAI_HD_BLOCKSIZE];
+	struct akai_cdinfohead_s *hp;
+	struct akai_voldir_entry_s *dep;
+	u_char *buf2;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return;
+	}
+
+	if (pp->type!=PART_TYPE_HD){
+		PRINTF_OUT("no CD-ROM info in this partition type\n");
+		return;
+	}
+	/* now, S1000/S3000 harddisk sampler partition */
+
+	/* check if S3000 with CD-ROM info: */
+	/* check if tags magic */
+	if (strncmp(AKAI_PARTHEAD_TAGSMAGIC,(char *)pp->head.hd.tagsmagic,4)!=0){
+		PRINTF_OUT("no CD-ROM info in this partition\n");
+		return;
+	}
+	/* check if at least minimum number of blocks for CD-ROM info have FAT code SYS */
+	/* Note: S1000 volume also uses SYS for volume directory */
+	for (i=AKAI_CDINFO_BLK;i<AKAI_CDINFO_BLK+AKAI_CDINFO_MINSIZB;i++){
+		c=(pp->fat[i][1]<<8)+pp->fat[i][0];
+		if (c!=AKAI_FAT_CODE_SYS){
+			PRINTF_OUT("no CD-ROM info in this partition\n");
+			return;
+		}
+	}
+
+	/* read CD-ROM info header */
+	if (akai_io_blks(pp,buf,
+					 AKAI_CDINFO_BLK,
+					 1,
+					 0,IO_BLKS_READ)<0){ /* 0: don't allocate new cache */
+		PRINTF_ERR("cannot read CD-ROM info\n");
+		return;
+	}
+
+	/* CD-ROM info header */
+	hp=(struct akai_cdinfohead_s *)buf;
+
+	/* CD-ROM label */
+	/* Note: CD-ROM label uses S1000/S3000 char conversion */
+	akai2ascii_name(hp->cdlabel,namebuf,0); /* 0: not S900 */
+	PRINTF_OUT("CD-ROM label: \"%s\"\n",namebuf);
+
+	/* number of files */
+	fnum=(hp->fnum[1]<<8)+hp->fnum[0];
+	PRINTF_OUT("\nnumber of files in partition %c: %u\n",pp->letter,fnum);
+	/* required number of blocks */
+	bn=sizeof(struct akai_cdinfohead_s)+fnum*sizeof(struct akai_voldir_entry_s);
+	bn=(bn+AKAI_HD_BLOCKSIZE-1)/AKAI_HD_BLOCKSIZE; /* round up */
+	if (AKAI_CDINFO_BLK+bn>pp->bsize){
+		PRINTF_ERR("invalid number of files for partition size\n");
+		return;
+	}
+	/* check if all required blocks for CD-ROM info have FAT code SYS */
+	/* Note: S1000 volume also uses SYS for volume directory */
+	for (i=1;i<bn;i++){
+		c=(pp->fat[AKAI_CDINFO_BLK+i][1]<<8)
+			+pp->fat[AKAI_CDINFO_BLK+i][0];
+		if (c!=AKAI_FAT_CODE_SYS){
+			/* truncate number of blocks */
+			bn=i;
+			/* truncate number of files */
+			fnum=((bn*AKAI_HD_BLOCKSIZE)-sizeof(struct akai_cdinfohead_s))/sizeof(struct akai_voldir_entry_s);
+			PRINTF_OUT("CD-ROM info is incomplete, truncated to %u files\n",fnum);
+			break;
+		}
+	}
+
+	if (verbose){
+		/* print volume sizes */
+		PRINTF_OUT("\nvolume files\n------------\n");
+		for (i=0;i<pp->volnummax;i++){
+			c=(hp->volesiz[i][1]<<8)+hp->volesiz[i][0]; /* size of volume directory entries for files in bytes */
+			if (c!=0){ /* used? */
+				c/=sizeof(struct akai_voldir_entry_s); /* number of file entries */
+				PRINTF_OUT("%03u      %3u\n",i+1,c);
+			}
+		}
+		PRINTF_OUT("------------\n");
+
+		if ((buf2=(u_char *)malloc(bn*AKAI_HD_BLOCKSIZE))==NULL){
+			PERROR("malloc");
+			return;
+		}
+
+		/* read directory of files from CD-ROM info */
+		if (akai_io_blks(pp,buf2,
+						 AKAI_CDINFO_BLK,
+						 bn,
+						 0,IO_BLKS_READ)<0){ /* 0: don't allocate new cache */
+			PRINTF_ERR("cannot read CD-ROM directory of files\n");
+			free(buf2);
+			return;
+		}
+
+		/* print directory of files */
+		PRINTF_OUT("\ndirectory of files:\n---------------------------------------------------------------------\n");
+		for (i=0;i<fnum;i++){
+			dep=(struct akai_voldir_entry_s *)(buf2+sizeof(struct akai_cdinfohead_s));
+			/* name */
+			/* Note: file names in CD-ROM info use S1000/S3000 char conversion */
+			akai2ascii_filename(dep[i].name,dep[i].type,AKAI_OSVER_S3000MAX,fnamebuf,0); /* 0: not S900 */
+			PRINTF_OUT("%-16s  ",fnamebuf);
+			if (i%4==3){
+				PRINTF_OUT("\n");
+			}
+		}
+		if (i%4!=0){
+			PRINTF_OUT("\n");
+		}
+		PRINTF_OUT("---------------------------------------------------------------------\n");
+
+		free(buf2);
+	}
+}
+
+
+
+int
+akai_set_cdinfo(struct part_s *pp,char *cdlabel)
+{
+	u_int c;
+	u_int i,j;
+	u_int fnum,fnummax;
+	u_int vsiz;
+	static u_char buf[AKAI_CDINFO_MINSIZB*AKAI_HD_BLOCKSIZE]; /* XXX minimum size */
+	u_char *bp;
+	struct akai_cdinfohead_s *hp;
+	struct vol_s vol;
+	struct file_s file;
+	u_char oldcdlabel[AKAI_NAME_LEN];
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+
+	if (pp->type!=PART_TYPE_HD){
+		PRINTF_OUT("no CD-ROM info in this partition type\n");
+		return -1;
+	}
+	/* now, S1000/S3000 harddisk sampler partition */
+
+	/* check if S3000 with CD-ROM info: */
+	/* check if tags magic */
+	if (strncmp(AKAI_PARTHEAD_TAGSMAGIC,(char *)pp->head.hd.tagsmagic,4)!=0){
+		PRINTF_OUT("no CD-ROM info in this partition\n");
+		return -1;
+	}
+	/* check if at least minimum number of blocks for CD-ROM info have FAT code SYS */
+	/* Note: S1000 volume also uses SYS for volume directory */
+	for (i=AKAI_CDINFO_BLK;i<AKAI_CDINFO_BLK+AKAI_CDINFO_MINSIZB;i++){
+		c=(pp->fat[i][1]<<8)+pp->fat[i][0];
+		if (c!=AKAI_FAT_CODE_SYS){
+			PRINTF_OUT("no CD-ROM info in this partition\n");
+			return -1;
+		}
+	}
+
+	/* CD-ROM info header */
+	hp=(struct akai_cdinfohead_s *)buf;
+
+	if (cdlabel==NULL){
+		/* read old CD-ROM info */
+		if (akai_io_blks(pp,buf,
+						 AKAI_CDINFO_BLK,
+						 1, /* XXX 1 block is enough for header */
+						 0,IO_BLKS_READ)<0){ /* 0: don't allocate new cache */
+			PRINTF_ERR("cannot read CD-ROM info\n");
+			return -1;
+		}
+		/* save old label */
+		bcopy(hp->cdlabel,oldcdlabel,AKAI_NAME_LEN);
+	}
+
+	/* wipe CD-ROM info */
+	bzero(buf,AKAI_CDINFO_MINSIZB*AKAI_HD_BLOCKSIZE);
+
+	/* max. number of files in CD-ROM info */
+	/* XXX minimum size */
+	fnummax=((AKAI_CDINFO_MINSIZB*AKAI_HD_BLOCKSIZE)-sizeof(struct akai_cdinfohead_s))/sizeof(struct akai_voldir_entry_s);
+
+	/* read all volumes in partition */
+	fnum=0;
+	bp=buf+sizeof(struct akai_cdinfohead_s); /* behind header */
+	for (i=0;i<pp->volnummax;i++){
+		vsiz=0;
+		if (akai_get_vol(pp,&vol,i)<0){
+			continue; /* ignore error, next */
+		}
+		/* check all files in volume */
+		for (j=0;j<vol.fimax;j++){
+			if (akai_get_file(&vol,&file,j)<0){
+				continue; /* ignore error, next */
+			}
+			/* copy volume entry */
+			bcopy(&vol.file[j],bp,sizeof(struct akai_voldir_entry_s));
+			bp+=sizeof(struct akai_voldir_entry_s);
+			vsiz+=sizeof(struct akai_voldir_entry_s);
+			fnum++;
+			if (fnum>=fnummax){
+				break; /* exit, ignore rest */
+			}
+		}
+		/* size of volume directory entries for files in bytes */
+		hp->volesiz[i][1]=0xff&(vsiz>>8);
+		hp->volesiz[i][0]=0xff&vsiz;
+		if (fnum>=fnummax){
+			break; /* exit, ignore rest */
+		}
+	}
+	/* total number of files */
+	hp->fnum[1]=0xff&(fnum>>8);
+	hp->fnum[0]=0xff&fnum;
+
+	/* CD-ROM label */
+	if (cdlabel!=NULL){
+		/* Note: CD-ROM label uses S1000/S3000 char conversion */
+		ascii2akai_name(cdlabel,hp->cdlabel,0); /* 0: not S900 */
+	}else{
+		/* restore old label */
+		bcopy(oldcdlabel,hp->cdlabel,AKAI_NAME_LEN);
+	}
+
+	/* write CD-ROM info */
+	if (akai_io_blks(pp,buf,
+					 AKAI_CDINFO_BLK,
+					 AKAI_CDINFO_MINSIZB,
+					 0,IO_BLKS_WRITE)<0){ /* 0: don't allocate new cache */
+		PRINTF_ERR("cannot write CD-ROM info\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+
+
+void
+akai_part_info(struct part_s *pp,int verbose)
+{
+
+	if (pp==NULL){
+		return;
+	}
+
+	if (verbose){
+		PRINTF_OUT("part:      ");
+		if (pp->type==PART_TYPE_DD){
+			/* harddisk DD partition */
+			if (pp->letter==0){
+				PRINTF_OUT("DD\n");
+			}else{
+				PRINTF_OUT("DD%u\n",(u_int)pp->letter);
+			}
+		}else{
+			/* floppy or harddisk sampler partition */
+			PRINTF_OUT("%c\n",pp->letter);
+		}
+		if (!pp->valid){
+			PRINTF_OUT("*** marked invalid ***\n");
+		}
+		PRINTF_OUT("parttype:  ");
+		switch (pp->type){
+		case PART_TYPE_FLL:
+			PRINTF_OUT("low-density floppy");
+			break;
+		case PART_TYPE_FLH:
+			PRINTF_OUT("high-density floppy");
+			break;
+		case PART_TYPE_HD9:
+			PRINTF_OUT("S900 harddisk");
+			break;
+		case PART_TYPE_HD:
+			PRINTF_OUT("S1000/S3000 harddisk sampler partition");
+			break;
+		case PART_TYPE_DD:
+			PRINTF_OUT("S1100/S3000 harddisk DD parttion");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?");
+			break;
+		}
+		PRINTF_OUT("\nblksize:   0x%04x bytes\n",pp->blksize);
+		PRINTF_OUT("start:     block 0x%04x\n",
+			pp->bstart);
+		PRINTF_OUT("size:      0x%04x blocks (%6u KB)\n",
+			pp->bsize,
+			(pp->bsize*pp->blksize)/1024); /* in KB */
+		PRINTF_OUT("free:      0x%04x blocks (%6u KB) = %5.1lf%%\n",
+			pp->bfree,
+			(pp->bfree*pp->blksize)/1024, /* in KB */
+			(pp->bsize>0)?(100.0*((double)pp->bfree)/((double)pp->bsize)):0.0);
+		PRINTF_OUT("bad:       0x%04x blocks (%6u KB) = %5.1lf%%\n",
+			pp->bbad,
+			(pp->bbad*pp->blksize)/1024, /* in KB */
+			(pp->bsize>0)?(100.0*((double)pp->bbad)/((double)pp->bsize)):0.0);
+		if (pp->type!=PART_TYPE_DD){
+			PRINTF_OUT("max. vols: %u\n",pp->volnummax);
+		}
+	}else{
+		if (pp->type==PART_TYPE_DD){
+			/* harddisk DD partition */
+			if (pp->letter==0){
+				PRINTF_OUT("  DD");
+			}else if (pp->letter<=9){
+				PRINTF_OUT(" DD%u",(u_int)pp->letter);
+			}else{
+				PRINTF_OUT("DD%u",(u_int)pp->letter);
+			}
+		}else{
+			/* floppy or harddisk sampler partition */
+			PRINTF_OUT("   %c",pp->letter);
+		}
+		PRINTF_OUT("%c  ",pp->valid?' ':'*');
+		switch (pp->type){
+		case PART_TYPE_FLL:
+			PRINTF_OUT("FLL");
+			break;
+		case PART_TYPE_FLH:
+			PRINTF_OUT("FLH");
+			break;
+		case PART_TYPE_HD9:
+			PRINTF_OUT("HD9");
+			break;
+		case PART_TYPE_HD:
+			PRINTF_OUT(" HD");
+			break;
+		case PART_TYPE_DD:
+			PRINTF_OUT(" DD");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?");
+			break;
+		}
+		PRINTF_OUT("   0x%04x    0x%04x    %5.1lf     0x%04x   %5.1lf  %5.1lf\n",
+			pp->bstart,
+			pp->bsize,
+			((double)pp->bsize*pp->blksize)/((double)1024*1024),
+			pp->bfree,
+			((double)pp->bfree*pp->blksize)/((double)1024*1024),
+			(pp->bsize>0)?(100.0*((double)pp->bfree)/((double)pp->bsize)):0.0);
+	}
+}
+
+void
+akai_list_part(struct part_s *pp,int recflag,u_char *filtertagp)
+{
+	u_int vi;
+	u_int ai;
+	struct vol_s tmpvol;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->diskp==NULL)){
+		return;
+	}
+
+	if (pp->type==PART_TYPE_DD){
+		/* harddisk DD partition */
+		u_int tott;
+		u_int i;
+
+		PRINTF_OUT("/disk%u/DD",pp->diskp->index);
+		if (pp->letter!=0){
+			PRINTF_OUT("%u",(u_int)pp->letter);
+		}
+		PRINTF_OUT("\ntnr  tname         cstarts cstarte csizes  csizee     scount  srate  stype\n");
+		PRINTF_OUT("---------------------------------------------------------------------------\n");
+		/* DD takes in partition */
+		tott=0;
+		for (i=0;i<AKAI_DDTAKE_MAXNUM;i++){
+			if (pp->head.dd.take[i].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+				continue; /* next */
+			}
+			tott++;
+			/* print DD take info */
+			akai_ddtake_info(pp,i,0);
+		}
+		PRINTF_OUT("---------------------------------------------------------------------------\n");
+		PRINTF_OUT("total: %3u take(s)\n\n",tott);
+
+		return;
+	}
+
+	/* now, floppy or harddisk sampler partition */
+
+	PRINTF_OUT("/disk%u/%c\n",pp->diskp->index,pp->letter);
+	PRINTF_OUT("vnr   vname         %s  startblk  osver  type\n",
+		(pp->type==PART_TYPE_HD9)?"alias":"lnum");
+	PRINTF_OUT("---------------------------------------------------\n");
+	/* volumes in partition */
+	ai=0;
+	for (vi=0;vi<pp->volnummax;vi++){
+		/* get volume */
+		if (akai_get_vol(pp,&tmpvol,vi)<0){
+			continue; /* next volume */
+		}
+		ai++;
+		/* print volume info */
+		akai_vol_info(&tmpvol,ai,0);
+	}
+	PRINTF_OUT("---------------------------------------------------\n");
+	PRINTF_OUT("total: %3u volume(s) (max. %3u)\n\n",ai,pp->volnummax);
+
+	if (recflag){
+		/* volumes in partition */
+		ai=0;
+		for (vi=0;vi<pp->volnummax;vi++){
+			/* get volume */
+			if (akai_get_vol(pp,&tmpvol,vi)<0){
+				continue; /* next volume */
+			}
+			if (tmpvol.type!=AKAI_VOL_TYPE_INACT){
+				/* list volume directory */
+				akai_list_vol(&tmpvol,filtertagp);
+			}
+		}
+	}
+}
+
+
+
+/* find partition with given name (letter) */
+struct part_s *
+akai_find_part(struct disk_s *dp,char *name)
+{
+	u_int p;
+	char namebuf[16]; /* XXX */
+
+	if ((dp==NULL)||(name==NULL)){
+		return NULL;
+	}
+
+	for (p=0;p<part_num;p++){
+		/* Note: allow even invalid partition to be found!!! */
+
+		if (part[p].diskp!=dp){ /* not on this disk? */
+			continue; /* next */
+		}
+
+		/* name */
+		if (part[p].type==PART_TYPE_DD){
+			if (part[p].letter==0){
+				sprintf(namebuf,"DD");
+			}else{
+				sprintf(namebuf,"DD%u",(u_int)part[p].letter);
+			}
+		}else{
+			sprintf(namebuf,"%c",part[p].letter);
+		}
+
+		/* compare name (case-insensitive) */
+		if (strcasecmp(namebuf,name)==0){ /* match? */
+			return &part[p]; /* found */
+		}
+	}
+
+	return NULL; /* not found */
+}
+
+
+
+void
+print_fat(struct part_s *pp)
+{
+	u_int i,ilim;
+	u_int j;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return;
+	}
+
+	PRINTF_OUT("%s    +0   +1   +2   +3   +4   +5   +6   +7\n----------------------------------------------\n",
+		(pp->type==PART_TYPE_DD)?"clu":"blk");
+	ilim=(pp->type==PART_TYPE_DD)?pp->csize:pp->bsize;
+	for (i=0;i<ilim;i++){
+		if ((i%8)==0){
+			PRINTF_OUT("%04x: ",i);
+		}
+		j=(pp->fat[i][1]<<8)+pp->fat[i][0];
+		if (pp->type==PART_TYPE_DD){ /* harddisk DD partition? */
+			switch (j){
+			case AKAI_DDFAT_CODE_FREE:
+				PRINTF_OUT(" -   ");
+				break;
+			case AKAI_DDFAT_CODE_BAD:
+				PRINTF_OUT(" BAD ");
+				break;
+			case AKAI_DDFAT_CODE_SYS:
+				PRINTF_OUT(" SYS ");
+				break;
+			case AKAI_DDFAT_CODE_END:
+				PRINTF_OUT(" END ");
+				break;
+			default:
+				PRINTF_OUT(" %04x",j);
+				break;
+			}
+		}else{
+			if (i<pp->bsyssize){ /* reserved block for system? */
+				PRINTF_OUT(" SYS ");
+			}else{
+				switch (j){
+				case AKAI_FAT_CODE_FREE: /* XXX same as AKAI_FAT_CODE_SYS900FL */
+					PRINTF_OUT(" -   ");
+					break;
+				case AKAI_FAT_CODE_BAD:
+					PRINTF_OUT(" BAD ");
+					break;
+				case AKAI_FAT_CODE_SYS900HD:
+				case AKAI_FAT_CODE_SYS: /* XXX same as AKAI_FAT_CODE_DIREND1000HD */
+					PRINTF_OUT(" SYS ");
+					break;
+				case AKAI_FAT_CODE_FILEEND900: /* XXX same as AKAI_FAT_CODE_DIREND900HD, AKAI_FAT_CODE_DIREND3000 */
+				case AKAI_FAT_CODE_FILEEND:
+					PRINTF_OUT(" END ");
+					break;
+				default:
+					PRINTF_OUT(" %04x",j);
+					break;
+				}
+			}
+		}
+		if (((i%8)==7)||(i+1==ilim)){
+			PRINTF_OUT("\n");
+		}
+	}
+	PRINTF_OUT("----------------------------------------------\n");
+}
+
+
+
+void
+akai_disk_info(struct disk_s *dp,int verbose)
+{
+	u_int totp;
+	u_int totf;
+	u_int totb;
+	u_int pi;
+
+	if (dp==NULL){
+		return;
+	}
+
+	/* scan all partitions in system */
+	totp=0;
+	totf=0;
+	totb=0;
+	for (pi=0;pi<part_num;pi++){
+		if (part[pi].diskp!=dp){ /* not this disk? */
+			continue;
+		}
+		totp++;
+		if (part[pi].valid){ /* valid? */
+			totf+=part[pi].bfree;
+			totb+=part[pi].bbad;
+		}
+	}
+	if (verbose){
+		PRINTF_OUT("disk:     %u\n",dp->index);
+		PRINTF_OUT("fd:       %i\n",dp->fd);
+#ifdef _VISUALCPP
+		PRINTF_OUT("fldrn:    %i\n",dp->fldrn);
+#endif /* _VISUALCPP */
+		PRINTF_OUT("start:    byte 0x%02x%08x\n",
+			(u_int)(dp->startoff>>32),
+			(u_int)(0xffffffff&dp->startoff));
+		PRINTF_OUT("parts:    %u\n",totp);
+		PRINTF_OUT("disktype: ");
+		switch (dp->type){
+		case DISK_TYPE_FLL:
+			PRINTF_OUT("low-density floppy");
+			break;
+		case DISK_TYPE_FLH:
+			PRINTF_OUT("high-density floppy");
+			break;
+		case DISK_TYPE_HD9:
+			PRINTF_OUT("S900 harddisk");
+			break;
+		case DISK_TYPE_HD:
+			PRINTF_OUT("S1000/S3000 harddisk");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?");
+			break;
+		}
+		PRINTF_OUT("\nblksize:  0x%04x bytes\n",dp->blksize);
+		PRINTF_OUT("total:    0x%04x blocks (%6u KB)\n",
+			dp->bsize,
+			dp->totsize/1024); /* in KB */
+		PRINTF_OUT("free:     0x%04x blocks (%6u KB) = %5.1lf%%\n",
+			totf,
+			(totf*dp->blksize)/1024, /* in KB */
+			(dp->bsize>0)?(100.0*((double)totf)/((double)dp->bsize)):0.0);
+		PRINTF_OUT("bad:      0x%04x blocks (%6u KB) = %5.1lf%%\n",
+			totb,
+			(totb*dp->blksize)/1024, /* in KB */
+			(dp->bsize>0)?(100.0*((double)totb)/((double)dp->bsize)):0.0);
+	}else{
+		PRINTF_OUT(" %3u   ",dp->index);
+		switch (dp->type){
+		case DISK_TYPE_FLL:
+			PRINTF_OUT("FLL");
+			break;
+		case DISK_TYPE_FLH:
+			PRINTF_OUT("FLH");
+			break;
+		case DISK_TYPE_HD9:
+			PRINTF_OUT("HD9");
+			break;
+		case DISK_TYPE_HD:
+			PRINTF_OUT(" HD");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?");
+			break;
+		}
+		PRINTF_OUT("   %3u   0x%04x   0x%04x   %5.1lf     0x%04x   %5.1lf  %5.1lf\n",
+			totp,
+			dp->blksize,
+			dp->bsize,
+			((double)dp->bsize*dp->blksize)/((double)1024*1024),
+			totf,
+			((double)totf*dp->blksize)/((double)1024*1024),
+			(dp->bsize>0)?(100.0*((double)totf)/((double)dp->bsize)):0.0);
+	}
+}
+
+void
+akai_list_disk(struct disk_s *dp,int recflag,u_char *filtertagp)
+{
+	u_int p;
+	u_int totp;
+
+	if (dp==NULL){
+		return;
+	}
+
+	PRINTF_OUT("/disk%u\n",dp->index);
+	PRINTF_OUT("part  type startblk size/blks  size/MB  free/blks free/MB free/%%\n");
+	PRINTF_OUT("----------------------------------------------------------------\n");
+	/* partitions on disk */
+	totp=0;
+	for (p=0;p<part_num;p++){
+		if (part[p].diskp==dp){ /* on this disk? */
+			/* print partition info */
+			akai_part_info(&part[p],0);
+			totp++;
+		}
+	}
+	PRINTF_OUT("----------------------------------------------------------------\n");
+	PRINTF_OUT("total: %3u partition(s)\n\n",totp);
+
+	if (recflag){
+		/* partitions on disk */
+		for (p=0;p<part_num;p++){
+			if ((part[p].diskp==dp) /* on this disk? */
+				&&(part[p].valid)){
+				/* list root directory in partition */
+				akai_list_part(&part[p],recflag,filtertagp);
+			}
+		}
+	}
+}
+
+void
+akai_list_alldisks(int recflag,u_char *filtertagp)
+{
+	u_int di;
+
+	PRINTF_OUT("/\n");
+	PRINTF_OUT("disk  type parts  blksize tot/blks  tot/MB  free/blks free/MB free/%%\n");
+	PRINTF_OUT("--------------------------------------------------------------------\n");
+	/* disks */
+	for (di=0;di<disk_num;di++){
+		/* print disk info */
+		akai_disk_info(&disk[di],0);
+	}
+	PRINTF_OUT("--------------------------------------------------------------------\n");
+	PRINTF_OUT("total: %3u disk(s)\n\n",disk_num);
+
+	if (recflag){
+		/* disks */
+		for (di=0;di<disk_num;di++){
+			/* list disk */
+			akai_list_disk(&disk[di],recflag,filtertagp);
+		}
+	}
+}
+
+
+
+void
+akai_sort_filetags(u_char *tagp)
+{
+	u_int i,j;
+	u_char b;
+
+	if (tagp==NULL){
+		return;
+	}
+
+	for (i=0;i<(AKAI_FILE_TAGNUM-1);i++){
+		for (j=i+1;j<AKAI_FILE_TAGNUM;j++){
+			if (tagp[i]>tagp[j]){
+				/* swap */
+				b=tagp[i];
+				tagp[i]=tagp[j];
+				tagp[j]=b;
+			}
+		}
+	}
+}
+
+
+
+int
+akai_match_filetags(u_char *filtertagp,u_char *testtagp)
+{
+	u_int i,j;
+
+	if (filtertagp==NULL){
+		return 0; /* no filter, matches always */
+	}
+	if (testtagp==NULL){
+		return -1; /* no match */
+	}
+
+	if (testtagp[0]==AKAI_FILE_TAGS1000){ /* XXX check if testtagp[] stems from S1000 */
+		/* now, match only if all entries in filtertagp[] are free */
+		for (i=0;i<AKAI_FILE_TAGNUM;i++){
+			if ((filtertagp[i]!=AKAI_FILE_TAGFREE)&&(filtertagp[i]!=AKAI_FILE_TAGS1000)){ /* not free? */
+				return -1; /* no match */
+			}
+		}
+
+		return 0; /* match */
+	}
+
+	for (i=0;i<AKAI_FILE_TAGNUM;i++){
+		if ((filtertagp[i]==AKAI_FILE_TAGFREE)||(filtertagp[i]==AKAI_FILE_TAGS1000)){ /* free? */
+			continue; /* next */
+		}
+		for (j=0;j<AKAI_FILE_TAGNUM;j++){
+			if ((testtagp[i]==AKAI_FILE_TAGFREE)||(testtagp[i]==AKAI_FILE_TAGS1000)){ /* free? */
+				continue; /* next */
+			}
+			if (testtagp[j]==filtertagp[i]){ /* found? */
+				break; /* found entry i */
+			}
+		}
+		if (j==AKAI_FILE_TAGNUM){ /* not found? */
+			return -1; /* no match */
+		}
+	}
+	/* now, all non-free entries of filtertagp[] are found in testtagp[] => match */
+
+	return 0; /* match */
+}
+
+
+
+int
+akai_set_filetag(u_char *tagp,u_int ti)
+{
+	u_int i;
+
+	if (tagp==NULL){
+		return -1;
+	}
+
+	if ((ti<1)||(ti>AKAI_PARTHEAD_TAGNUM)){
+		PRINTF_ERR("invalid tag index\n");
+		return -1;
+	}
+
+	/* check if already present */
+	for (i=0;i<AKAI_FILE_TAGNUM;i++){
+		if (tagp[i]==ti){
+			return 0; /* nothing to do */
+		}
+	}
+
+	/* find free entry */
+	for (i=0;i<AKAI_FILE_TAGNUM;i++){
+		if ((tagp[i]==AKAI_FILE_TAGFREE)||(tagp[i]==AKAI_FILE_TAGS1000)){ /* free? */
+			break; /* found */
+		}
+	}
+	if (i==AKAI_FILE_TAGNUM){ /* none found? */
+		PRINTF_OUT("no free tag entry\n");
+		return -1;
+	}
+	/* set tag */
+	tagp[i]=ti;
+
+	akai_sort_filetags(tagp);
+
+	return 0;
+}
+
+
+
+int
+akai_clear_filetag(u_char *tagp,u_int ti)
+{
+	u_int i;
+
+	if (tagp==NULL){
+		return -1;
+	}
+
+	/* XXX allow to clear invalid tag index */
+
+	if (ti==AKAI_FILE_TAGFREE){
+		/* clear all */
+		for (i=0;i<AKAI_FILE_TAGNUM;i++){
+			tagp[i]=AKAI_FILE_TAGFREE;
+		}
+	}else if (ti==AKAI_FILE_TAGS1000){
+		/* clear all */
+		for (i=0;i<AKAI_FILE_TAGNUM;i++){
+			tagp[i]=AKAI_FILE_TAGS1000;
+		}
+	}else{
+		/* find entry */
+		for (i=0;i<AKAI_FILE_TAGNUM;i++){
+			if (tagp[i]==ti){
+				/* clear */
+				tagp[i]=AKAI_FILE_TAGFREE;
+				/* Note: must not break, must find (although invalid) repitions as well */
+			}
+		}
+	}
+
+	akai_sort_filetags(tagp);
+
+	return 0;
+}
+
+
+
+/* get file with index fi */
+/* saves result in *fp */
+int
+akai_get_file(struct vol_s *vp,struct file_s *fp,u_int fi)
+{
+
+	if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)||(vp->file==NULL)){
+		return -1;
+	}
+	if ((vp->partp==NULL)||(!vp->partp->valid)){
+		return -1;
+	}
+	if (fp==NULL){
+		return -1;
+	}
+
+	if (fi>=vp->fimax){
+		return -1;
+	}
+
+	/* in volume */
+	fp->volp=vp;
+
+	/* index */
+	fp->index=fi;
+
+	/* type */
+	fp->type=vp->file[fi].type;
+	if (fp->type==AKAI_FTYPE_FREE){ /* free entry? */
+		return -1;
+	}
+
+	/* tags */
+	bcopy(vp->file[fi].tag,fp->tag,AKAI_FILE_TAGNUM);
+
+	/* osver: */
+	/* if S1000/S3000: OS version */
+	/* if S900 compressed file: number of un-compressed floppy blocks */
+	/* else: zero */
+	fp->osver=(vp->file[fi].osver[1]<<8)
+			  +vp->file[fi].osver[0];
+
+	/* name */
+	akai2ascii_filename(vp->file[fi].name,(u_char)fp->type,fp->osver,fp->name,vp->type==AKAI_VOL_TYPE_S900);
+
+	/* size */
+	fp->size=(vp->file[fi].size[2]<<16)
+			 +(vp->file[fi].size[1]<<8)
+			 +vp->file[fi].size[0];
+
+	/* start */
+	fp->bstart=(vp->file[fi].start[1]<<8)
+			   +vp->file[fi].start[0];
+
+	return 0;
+}
+
+
+
+/* find file with given name */
+/* saves result in *fp */
+int
+akai_find_file(struct vol_s *vp,struct file_s *fp,char *name)
+{
+	u_int fi;
+	char namebuf[AKAI_NAME_LEN+4+1]; /* +4 for ".<type>", +1 for '\0' */
+	u_int i,j,k,l;
+
+	if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)){
+		return -1;
+	}
+	if ((vp->partp==NULL)||(!vp->partp->valid)){
+		return -1;
+	}
+	if (fp==NULL){
+		return -1;
+	}
+	if (name==NULL){
+		return -1;
+	}
+
+	/* fix name */
+	l=(u_int)strlen(name);
+	if (l>AKAI_NAME_LEN+4){ /* too long for namebuf? */
+		return -1;
+	}
+	j=l; /* end */
+	for (i=0;i<l;i++){
+		if (name[i]=='_'){ /* for keyboard entry */
+			namebuf[i]=' ';
+		}else{
+			namebuf[i]=name[i];
+			if (name[i]=='.'){
+				j=i; /* last '.' so far */
+			}
+		}
+	}
+	namebuf[i]='\0';
+	/* remove trailing ' ' (XXX don't care how many) before last '.' (or end if no '.') */
+	k=j;
+	for (i=0;i<j;i++){
+		if (namebuf[j-i-1]==' '){
+			namebuf[j-i-1]='\0';
+			k--;
+		}else{
+			break;
+		}
+	}
+	if ((k<j)&&(j<l)){
+		/* move ".<type>" */
+		for (i=0;(k+i<l)&&(j+i<l);i++){
+			namebuf[k+i]=namebuf[j+i];
+		}
+		namebuf[k+i]='\0';
+	}
+
+	/* files in volume directory */
+	for (fi=0;fi<vp->fimax;fi++){
+		/* get file */
+		if (akai_get_file(vp,fp,fi)<0){
+			continue; /* next file */
+		}
+
+		/* compare name (case-insensitive) */
+		if (strcasecmp(fp->name,namebuf)==0){ /* match? */
+			return 0; /* found */
+		}
+	}
+
+	return -1; /* not found */
+}
+
+
+
+int
+akai_rename_file(struct file_s *fp,char *name,struct vol_s *vp,u_int dstindex,u_char *tagp,u_int osver)
+{
+	u_int i;
+	u_int diffvolflag;
+	u_int fisrc,fidst;
+	struct vol_s *volsrcp,*voldstp;
+	u_char ft;
+	u_char anamebuf[AKAI_NAME_LEN];
+
+	if ((fp==NULL)||(fp->type==AKAI_FTYPE_FREE)){
+		return -1;
+	}
+	if ((fp->volp==NULL)||(fp->volp->type==AKAI_VOL_TYPE_INACT)||(fp->volp->file==NULL)){
+		return -1;
+	}
+	if ((fp->volp->partp==NULL)||(!fp->volp->partp->valid)){
+		return -1;
+	}
+
+	if ((vp!=NULL)&&((vp->type==AKAI_VOL_TYPE_INACT)||(vp->file==NULL))){
+		return -1;
+	}
+	if ((vp!=NULL)&&(vp->partp!=fp->volp->partp)){ /* if vp specified: not on same partition? */
+		PRINTF_OUT("must be in same partition\n");
+		return -1;
+	}
+
+	/* Note: must not compare pointers (vp and fp->volp) if the buffer behind volume pointer is not unique for each volume!!! */
+	/*       use dirblk[0] instead, which is unique if same partition (see check above) */
+	if ((vp!=NULL)&&(vp->dirblk[0]!=fp->volp->dirblk[0])){ /* different volume specified? */
+		diffvolflag=1;
+	}else{
+		diffvolflag=0;
+	}
+
+	if ((name==NULL)&&((osver!=fp->osver)||diffvolflag)){ /* no new name but different OS version or different volume? */
+		/* possibly different char conversion or possibly need to correct osver -> handle as new name below */
+		name=fp->name;
+	}
+
+	if ((diffvolflag==0)&&(name==NULL)&&(tagp==NULL)){ /* nothing to do? */
+		return 0; /* done */
+	}
+
+	/* source file */
+	fisrc=fp->index;
+	volsrcp=fp->volp;
+
+	if (diffvolflag){ /* different volume specified? */
+		voldstp=vp;
+		if (dstindex==AKAI_CREATE_FILE_NOINDEX){ /* no user-supplied index? */
+			/* find free destination volume directory entry */
+			for (fidst=0;fidst<voldstp->fimax;fidst++){
+				if (voldstp->file[fidst].type==AKAI_FTYPE_FREE){ /* free? */
+					break; /* found one */
+				}
+			}
+			if (fidst==voldstp->fimax){ /* none found? */
+				PRINTF_OUT("no free file entry found\n");
+				return -1;
+			}
+		}else{
+			if (voldstp->file[dstindex].type!=AKAI_FTYPE_FREE){ /* not free? */
+				PRINTF_OUT("destination index not free\n");
+				return -1;
+			}
+			fidst=dstindex;
+		}
+	}else{
+		/* same volume */
+		voldstp=volsrcp;
+		if ((dstindex==AKAI_CREATE_FILE_NOINDEX) /* no user-supplied index? */
+			||(dstindex==fisrc)){ /* or same as before? */
+			fidst=fisrc; /* keep index */
+		}else{
+			if (voldstp->file[dstindex].type!=AKAI_FTYPE_FREE){ /* not free? */
+				PRINTF_OUT("destination index not free\n");
+				return -1;
+			}
+			fidst=dstindex; /* new index */
+		}
+	}
+
+	/* name and type */
+	ft=0;
+	if (name!=NULL){ /* new name? */
+		/* new name and type and possibly correct osver */
+		ft=ascii2akai_filename(name,anamebuf,&osver,voldstp->type==AKAI_VOL_TYPE_S900);
+		if (ft==AKAI_FTYPE_FREE){
+			PRINTF_ERR("invalid name\n");
+			return -1;
+		}
+	}
+
+	/* update volume entries (after having checked the name!!!) */
+
+	if (diffvolflag||(fidst!=fisrc)){ /* different volume specified, or different index within same volume? */
+		/* create destination volume directory entry */
+		bcopy(&volsrcp->file[fisrc],&voldstp->file[fidst],sizeof(struct akai_voldir_entry_s));
+
+		/* new volume */
+		fp->volp=voldstp;
+
+		/* new index */
+		fp->index=fidst;
+
+		/* free old volume directory entry */
+		bzero(&volsrcp->file[fisrc],sizeof(struct akai_voldir_entry_s));
+		volsrcp->file[fisrc].type=AKAI_FTYPE_FREE;
+
+		/* write source volume directory */
+		if (akai_write_voldir(volsrcp,fisrc)<0){
+			return -1;
+		}
+	}
+
+	/* set destination volume directory entry */
+
+	if (osver!=fp->osver){ /* different OS version? */
+		/* new OS version */
+		fp->osver=osver;
+		voldstp->file[fidst].osver[1]=0xff&(fp->osver>>8);
+		voldstp->file[fidst].osver[0]=0xff&fp->osver;
+	}
+
+	/* name and type */
+	if (name!=NULL){ /* new name/type? */
+		/* new name */
+		if (vp->type==AKAI_VOL_TYPE_S900){
+			bcopy(anamebuf,voldstp->file[fidst].name,AKAI_NAME_LEN_S900);
+			bzero(voldstp->file[fidst].name+AKAI_NAME_LEN_S900,AKAI_NAME_LEN-AKAI_NAME_LEN_S900);
+		}else{
+			bcopy(anamebuf,voldstp->file[fidst].name,AKAI_NAME_LEN);
+		}
+		if (name!=fp->name){ /* not already in fp->name? */
+			/* copy */
+			strcpy(fp->name,name); /* Note: name has been checked above */
+		}
+
+		/* new type */
+		voldstp->file[fidst].type=ft;
+		fp->type=ft;
+	}
+	/* else: keep old name and type */
+	/*       No need to copy since whole dir entry has been copied above if necessary */
+
+	/* tags */
+	if (vp->type==AKAI_VOL_TYPE_S900){
+		/* S900 */
+		/* no tags */
+		for (i=0;i<AKAI_FILE_TAGNUM;i++){
+			fp->tag[i]=AKAI_FILE_TAGFREE;
+		}
+		bzero(voldstp->file[fidst].tag,AKAI_FILE_TAGNUM);
+	}else{
+		/* S1000/S3000 */
+		if (tagp!=NULL){ /* new tags? */
+			/* copy tags */
+			bcopy(tagp,voldstp->file[fidst].tag,AKAI_FILE_TAGNUM);
+			akai_sort_filetags(voldstp->file[fidst].tag);
+			if (tagp!=fp->tag){ /* not already in fp->tag? */
+				/* copy */
+				bcopy(voldstp->file[fidst].tag,fp->tag,AKAI_FILE_TAGNUM);
+				/* XXX no check for validity of tag indices */
+			}
+		}
+		/* else: keep old tags */
+		/*       No need to copy since whole dir entry has been copied above if necessary */
+	}
+
+	/* write destination volume directory */
+	/* Note: the same partition for source and destination */
+	if (akai_write_voldir(voldstp,fidst)<0){
+		return -1;
+	}
+
+	return 0;
+}
+
+
+
+/* uses *fp as output */
+/* size in bytes */
+int
+akai_create_file(struct vol_s *vp,struct file_s *fp,u_int size,u_int index,char *name,u_int osver,u_char *tagp)
+{
+	u_char ft;
+	u_int bsize;
+	u_int fi;
+	u_int i;
+	u_char anamebuf[AKAI_NAME_LEN];
+
+	if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)||(vp->file==NULL)){
+		return -1;
+	}
+	if ((vp->partp==NULL)||(!vp->partp->valid)||(vp->partp->blksize==0)){
+		return -1;
+	}
+	if (fp==NULL){
+		return -1;
+	}
+	if (name==NULL){
+		return -1;
+	}
+
+	if (size>AKAI_FILE_SIZEMAX){
+		PRINTF_ERR("file size is too large\n");
+		return -1;
+	}
+
+	/* volume */
+	fp->volp=vp;
+
+	/* name and type and possibly correct osver */
+	ft=ascii2akai_filename(name,anamebuf,&osver,vp->type==AKAI_VOL_TYPE_S900);
+	if (ft==AKAI_FTYPE_FREE){
+		PRINTF_ERR("invalid name\n");
+		return -1;
+	}
+	/* now, lengths also OK */
+	strcpy(fp->name,name);
+	fp->type=ft;
+
+	/* osver */
+	fp->osver=osver;
+
+	/* index */
+	if (index==AKAI_CREATE_FILE_NOINDEX){ /* no user-supplied volume index? */
+		/* find free volume directory entry */
+		for (fi=0;fi<vp->fimax;fi++){
+			if (vp->file[fi].type==AKAI_FTYPE_FREE){ /* free? */
+				break; /* found one */
+			}
+		}
+		if (fi==vp->fimax){ /* none found? */
+			PRINTF_OUT("no free file entry found\n");
+			return -1;
+		}
+	}else{
+		/* user-supplied index */
+		fi=index;
+		if (fi>vp->fimax){
+			return -1;
+		}
+		if (vp->file[fi].type!=AKAI_FTYPE_FREE){ /* not free? */
+			PRINTF_OUT("file entry not free\n");
+			return -1;
+		}
+	}
+	fp->index=fi;
+
+	/* size */
+	fp->size=size;
+
+	/* tags */
+	if (vp->type==AKAI_VOL_TYPE_S900){
+		/* S900 */
+		/* no tags */
+		for (i=0;i<AKAI_FILE_TAGNUM;i++){
+			fp->tag[i]=AKAI_FILE_TAGFREE;
+		}
+	}else{
+		/* S1000/S3000 */
+		if (tagp!=NULL){
+			/* correct and copy */
+			/* Note: even if tagp==fp->tag */
+			for (i=0;i<AKAI_FILE_TAGNUM;i++){
+				if ((tagp[i]>=1)&&(tagp[i]<=AKAI_PARTHEAD_TAGNUM)){
+					fp->tag[i]=tagp[i];
+				}else{
+					/* set free */
+					if (fp->osver<=AKAI_OSVER_S1100MAX){
+						fp->tag[i]=AKAI_FILE_TAGS1000;
+					}else{
+						fp->tag[i]=AKAI_FILE_TAGFREE;
+					}
+				}
+			}
+			akai_sort_filetags(fp->tag);
+		}else{
+			/* all free */
+			for (i=0;i<AKAI_FILE_TAGNUM;i++){
+				if (fp->osver<=AKAI_OSVER_S1100MAX){
+					fp->tag[i]=AKAI_FILE_TAGS1000;
+				}else{
+					fp->tag[i]=AKAI_FILE_TAGFREE;
+				}
+			}
+		}
+	}
+
+	/* allocate space */
+	bsize=(fp->size+fp->volp->partp->blksize-1)/fp->volp->partp->blksize; /* round up */
+	if (akai_allocate_fatchain(vp->partp,bsize,
+							   &fp->bstart,
+							   1,
+							   (vp->type==AKAI_VOL_TYPE_S900)?AKAI_FAT_CODE_FILEEND900:AKAI_FAT_CODE_FILEEND)<0){ /* end code */
+		return -1;
+	}
+
+	/* create volume directory entry */
+	bzero(&vp->file[fi],sizeof(struct akai_voldir_entry_s));
+	if (vp->type==AKAI_VOL_TYPE_S900){
+		/* S900 */
+		/* name */
+		bcopy(anamebuf,vp->file[fi].name,AKAI_NAME_LEN_S900);
+		bzero(vp->file[fi].name+AKAI_NAME_LEN_S900,AKAI_NAME_LEN-AKAI_NAME_LEN_S900);
+		/* no tags */
+		bzero(vp->file[fi].tag,AKAI_FILE_TAGNUM);
+	}else{
+		/* S1000/S3000 */
+		/* name */
+		bcopy(anamebuf,vp->file[fi].name,AKAI_NAME_LEN);
+		/* tags */
+		bcopy(fp->tag,vp->file[fi].tag,AKAI_FILE_TAGNUM);
+	}
+	/* type */
+	vp->file[fi].type=fp->type;
+	/* size */
+	vp->file[fi].size[2]=0xff&(fp->size>>16);
+	vp->file[fi].size[1]=0xff&(fp->size>>8);
+	vp->file[fi].size[0]=0xff&fp->size;
+	/* start */
+	vp->file[fi].start[1]=0xff&(fp->bstart>>8);
+	vp->file[fi].start[0]=0xff&fp->bstart;
+	/* OS version */
+	vp->file[fi].osver[1]=0xff&(fp->osver>>8);
+	vp->file[fi].osver[0]=0xff&fp->osver;
+
+	/* write volume directory */
+	if (akai_write_voldir(vp,fi)<0){
+		return -1;
+	}
+
+	return 0;
+}
+
+
+
+void
+akai_fvol1000_initfile(struct akai_voldir_entry_s *ep,u_int osver,u_int tag)
+{
+	u_int i;
+
+	if (ep==NULL){
+		return;
+	}
+
+	/* OS version */
+	ep->osver[1]=0xff&(osver>>8);
+	ep->osver[0]=0xff&osver;
+
+	if (osver==AKAI_OSVER_S900VOL){
+		/* S900 */
+		/* zero name and tags */
+		bzero(ep->name,AKAI_NAME_LEN);
+		bzero(ep->tag,AKAI_FILE_TAGNUM);
+	}else{
+		/* S1000/S3000 */
+		/* default name */
+		ascii2akai_name(AKAI_EMPTY1000_FNAME,ep->name,0); /* 0: not S900 */
+		/* default tags */
+		for (i=0;i<AKAI_FILE_TAGNUM;i++){
+			ep->tag[i]=tag;
+		}
+	}
+
+	/* type: free entry */
+	ep->type=AKAI_FTYPE_FREE;
+}
+
+int
+akai_delete_file(struct file_s *fp)
+{
+	u_int fi;
+
+	if ((fp==NULL)||(fp->type==AKAI_FTYPE_FREE)){
+		return -1;
+	}
+	if ((fp->volp==NULL)||(fp->volp->type==AKAI_VOL_TYPE_INACT)||(fp->volp->file==NULL)){
+		return -1;
+	}
+	if ((fp->volp->partp==NULL)||(!fp->volp->partp->valid)){
+		return -1;
+	}
+
+	/* file index */
+	fi=fp->index;
+
+	/* free volume directory entry */
+	bzero(&fp->volp->file[fi],sizeof(struct akai_voldir_entry_s));
+	if ((fp->volp->partp->type==PART_TYPE_HD9)
+		||(fp->volp->partp->type==PART_TYPE_HD)
+		||(fp->volp->type==AKAI_VOL_TYPE_S3000)||(fp->volp->type==AKAI_VOL_TYPE_CD3000)){
+		/* harddisk and/or S3000 volume */
+		fp->volp->file[fi].type=AKAI_FTYPE_FREE;
+	}else{
+		/* S900/S1000 floppy */
+		akai_fvol1000_initfile(&fp->volp->file[fi],fp->volp->osver,AKAI_FILE_TAGS1000);
+	}
+
+	/* write volume directory */
+	if (akai_write_voldir(fp->volp,fi)<0){
+		return -1;
+	}
+
+	/* free FAT chain */
+	if (akai_free_fatchain(fp->volp->partp,fp->bstart,1)<0){ /* 1: write FAT */
+		PRINTF_ERR("failed to free blocks of file, however, volume directory entry deleted\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+
+
+int
+akai_rename_ddtake(struct part_s *pp,u_int ti,char *name)
+{
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+
+	if (ti>=AKAI_DDTAKE_MAXNUM){
+		return -1;
+	}
+
+	if (name==NULL){
+		return -1;
+	}
+
+	if (pp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+		return -1;
+	}
+
+	/* rename */
+	ascii2akai_name(name,pp->head.dd.take[ti].name,0); /* 0: not S900 */
+
+	/* write partition header */
+	if (akai_io_blks(pp,(u_char *)&pp->head.dd,
+					 0,
+					 AKAI_DDPARTHEAD_BLKS,
+					 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+		return -1;
+	}
+
+	return 0;
+}
+
+int
+akai_delete_ddtake(struct part_s *pp,u_int ti)
+{
+	u_int cstarts,cstarte;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+
+	if (ti>=AKAI_DDTAKE_MAXNUM){
+		return -1;
+	}
+
+	if (pp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+		return -1;
+	}
+
+	/* free DD FAT chains */
+	cstarts=(pp->head.dd.take[ti].cstarts[1]<<8)
+		    +pp->head.dd.take[ti].cstarts[0];
+	if (cstarts!=0){ /* sample not empty? */
+		if (akai_free_ddfatchain(pp,cstarts,0)<0){ /* 0: don't write header yet */
+			return -1;
+		}
+	}
+	cstarte=(pp->head.dd.take[ti].cstarte[1]<<8)
+		    +pp->head.dd.take[ti].cstarte[0];
+	if (cstarte!=0){ /* envelope not empty? */
+		if (akai_free_ddfatchain(pp,cstarte,0)<0){ /* 0: don't write header yet */
+			return -1;
+		}
+	}
+
+	/* wipe directory entry for take */
+	bzero(&pp->head.dd.take[ti],sizeof(struct akai_ddtake_s));
+	pp->head.dd.take[ti].stat=AKAI_DDTAKESTAT_FREE; /* free */
+
+	/* count free and bad blocks */
+	akai_countfree_part(pp);
+
+	/* write partition header */
+	if (akai_io_blks(pp,(u_char *)&pp->head.dd,
+					 0,
+					 AKAI_DDPARTHEAD_BLKS,
+					 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+		return -1;
+	}
+
+	return 0;
+}
+
+
+
+void
+akai_fix_partheadmagic(struct part_s *pp)
+{
+	u_int i;
+	u_int m,cs;
+
+	/* Note: allow invalid partitions to be fixed!!! */
+	if (pp==NULL){
+		return;
+	}
+	if (pp->type!=PART_TYPE_HD){
+		return;
+	}
+	/* now, S1000/S3000 harddisk sampler partition */
+
+	cs=pp->bsize;
+
+	/* set magic */
+	for (i=0;i<AKAI_PARTHEAD_MAGICNUM;i++){
+		m=0xffff&(i*AKAI_PARTHEAD_MAGICVAL);
+		pp->head.hd.magic[i][1]=0xff&(m>>8);
+		pp->head.hd.magic[i][0]=0xff&m;
+		cs+=m;
+	}
+
+	/* set checksum */
+	pp->head.hd.chksum[3]=0xff&(cs>>24);
+	pp->head.hd.chksum[2]=0xff&(cs>>16);
+	pp->head.hd.chksum[1]=0xff&(cs>>8);
+	pp->head.hd.chksum[0]=0xff&cs;
+}
+
+int
+akai_check_partheadmagic(struct part_s *pp)
+{
+	u_int i;
+	u_int m,cs,c;
+
+	/* Note: allow invalid partitions to be checked!!! */
+	if (pp==NULL){
+		return -1;
+	}
+	if (pp->type==PART_TYPE_DD){
+		return -1;
+	}
+
+	cs=pp->bsize;
+
+	/* magic */
+	for (i=0;i<AKAI_PARTHEAD_MAGICNUM;i++){
+		m=(pp->head.hd.magic[i][1]<<8)
+		  +pp->head.hd.magic[i][0];
+		if (m!=(0xffff&(i*AKAI_PARTHEAD_MAGICVAL))){
+			return -1; /* magic error */
+		}
+		cs+=m;
+	}
+
+	/* checksum */
+	c=(pp->head.hd.chksum[3]<<24)
+	  +(pp->head.hd.chksum[2]<<16)
+	  +(pp->head.hd.chksum[1]<<8)
+	  +pp->head.hd.chksum[0];
+	if (c!=cs){
+		return -2; /* only checksum error */
+	}
+
+	return 0; /* OK */
+}
+
+void
+akai_fix_parttabmagic(struct akai_parttab_s *ptp)
+{
+	u_int i;
+	u_int m;
+
+	if (ptp==NULL){
+		return;
+	}
+
+	/* set magic */
+	for (i=0;i<AKAI_PARTTAB_MAGICNUM;i++){
+		m=0xffff&(i*AKAI_PARTTAB_MAGICVAL);
+		ptp->magic[i][1]=0xff&(m>>8);
+		ptp->magic[i][0]=0xff&m;
+	}
+}
+
+int
+akai_check_parttabmagic(struct akai_parttab_s *ptp)
+{
+	u_int i;
+	u_int m;
+
+	if (ptp==NULL){
+		return -1;
+	}
+
+	/* magic */
+	for (i=0;i<AKAI_PARTTAB_MAGICNUM;i++){
+		m=(ptp->magic[i][1]<<8)+ptp->magic[i][0];
+		if (m!=(0xffff&(i*AKAI_PARTTAB_MAGICVAL))){
+			return -1; /* magic error */
+		}
+	}
+
+	return 0; /* OK */
+}
+
+
+
+int
+akai_scan_floppy(struct disk_s *dp)
+{
+	u_int i,n;
+
+	if (dp==NULL){
+		return -1;
+	}
+
+	/* disk blocksize and total size */
+	if (dp->blksize!=AKAI_FL_BLOCKSIZE){ /* wrong blocksize? */
+		/* set new blksize */
+		dp->blksize=AKAI_FL_BLOCKSIZE;
+		/* disk size in blocks */
+		dp->bsize=dp->totsize/dp->blksize;
+	} /* else: assume that dp->bsize is valid */
+
+#ifdef _VISUALCPP
+	if (dp->fldrn>=0){ /* is floppy drive? */
+		/* Note: open_disk() has set disk type */
+		/* check if no floppy inserted */
+		if (fldr_checkfloppyinserted(dp->fldrn)!=0){
+			PRINTF_OUT("disk%u: no floppy inserted\n",dp->index);
+			/* discard this partition, keep old part_num */
+			return -1;
+		}
+	}else /* no floppy drive */
+#endif /* _VISUALCPP */
+	{
+		/* set disk type */
+		/* Note: requires valid dp->bsize (see above) */
+		if (dp->bsize>=AKAI_FLH_SIZE){
+			dp->type=DISK_TYPE_FLH;
+		}else{
+			dp->type=DISK_TYPE_FLL;
+		}
+	}
+
+	/* disk pointer */
+	part[part_num].diskp=dp;
+
+	part[part_num].valid=1; /* OK so far */
+
+	/* set partition type = disk type (first guess) */
+	part[part_num].type=dp->type;
+
+	/* fake index on disk */
+	part[part_num].index=0;
+
+	/* block size */
+	part[part_num].blksize=dp->blksize;
+
+	/* start block */
+	part[part_num].bstart=0;
+
+	/* size (Note: also needed to read floppy header below) */
+	/* first guess: disk size (Note: part[part_num].bstart==0) */
+	part[part_num].bsize=dp->bsize;
+
+	/* try to read floppy header at block 0 relative to start */
+	/* Note: low- and high-density floppy headers are identical */
+	/*       up to first AKAI_FAT_ENTRIES_FLL FAT-entries!!! */
+	/* => try to read the largest header (AKAI_FLHHEAD_BLKS blocks) */
+	/* XXX bad luck for low-density floppy which has bad block(s) */
+	/*     at AKAI_FLLHEAD_BLKS <= block < AKAI_FLHHEAD_BLKS */
+	if ((part[part_num].bsize<AKAI_FLHHEAD_BLKS)
+		||(akai_io_blks(&part[part_num],(u_char *)&part[part_num].head.flh,
+						0,
+						AKAI_FLHHEAD_BLKS,
+						1,IO_BLKS_READ)<0)){ /* 1: alloc cache if possible */
+		PRINTF_OUT("disk%u: cannot read floppy header\n",dp->index);
+		/* discard this partition, keep old part_num */
+		/* assume end of disk, done */
+		return -1;
+	}
+
+	/* start of FAT */
+	/* Note: see comment above: FAT-start same for low- and high density */
+	part[part_num].fat=&part[part_num].head.flh.fatblk[0];
+
+	part[part_num].bsize=AKAI_FLH_SIZE;
+	/* count S1000/S3000 system blocks in FAT */
+	for (i=0;i<(AKAI_FLHHEAD_BLKS+AKAI_VOLDIR3000FL_BLKS);i++){
+		n=(part[part_num].fat[i][1]<<8)+part[part_num].fat[i][0];
+		if (n!=AKAI_FAT_CODE_SYS){ /* not reserved for system anymore? */
+			break; /* end of system blocks */
+		}
+	}
+	if (i>0){
+		/* assume S1000/S3000 */
+		/* reserved blocks for system */
+		part[part_num].bsyssize=i;
+		/* check floppy type */
+		if ((dp->bsize>=AKAI_FLL_SIZE)&&(dp->bsize<AKAI_FLH_SIZE)
+			&&((i==AKAI_FLLHEAD_BLKS)||(i==(AKAI_FLLHEAD_BLKS+AKAI_VOLDIR3000FL_BLKS)))){ /* S1000 or S3000 low-density? */
+			/* if correct, must be low-density floppy now */
+			part[part_num].type=PART_TYPE_FLL;
+			part[part_num].bsize=AKAI_FLL_SIZE;
+			/* Note: see comment above: no need to read low-density header again */
+		}else if ((dp->bsize>=AKAI_FLH_SIZE)
+				  &&((i==AKAI_FLHHEAD_BLKS)||(i==(AKAI_FLHHEAD_BLKS+AKAI_VOLDIR3000FL_BLKS)))){ /* S1000 or S3000 high-density? */
+			/* if correct, must be high-density floppy now */
+			part[part_num].type=PART_TYPE_FLH;
+			part[part_num].bsize=AKAI_FLH_SIZE;
+		}else{
+			return -1;
+		}
+	}else{
+		/* count S900 system blocks in FAT */
+		for (i=0;i<AKAI_FLHHEAD_BLKS;i++){
+			n=(part[part_num].fat[i][1]<<8)+part[part_num].fat[i][0];
+			if (n!=AKAI_FAT_CODE_SYS900FL){ /* not reserved for system anymore? */
+				break; /* end of system blocks */
+			}
+		}
+		/* reserved blocks for system */
+		part[part_num].bsyssize=i;
+		/* check floppy type */
+		/* Note: since AKAI_FAT_CODE_SYS900FL==AKAI_FAT_CODE_FREE, */
+		/*       a low-density floppy may have i>=AKAI_FLLHEAD_BLKS here */
+		if ((dp->bsize>=AKAI_FLL_SIZE)&&(dp->bsize<AKAI_FLH_SIZE)&&(i>=AKAI_FLLHEAD_BLKS)){ /* low-density? */
+			/* if correct, must be low-density floppy now */
+			part[part_num].type=PART_TYPE_FLL;
+			part[part_num].bsize=AKAI_FLL_SIZE;
+			/* Note: AKAI_FLLHEAD_BLKS system blocks, i may differ */
+			part[part_num].bsyssize=AKAI_FLLHEAD_BLKS;
+			/* Note: see comment above: no need to read low-density header again */
+		}else if ((dp->bsize>=AKAI_FLH_SIZE)&&(i==AKAI_FLHHEAD_BLKS)){ /* high-density? */
+			/* if correct, must be high-density floppy now */
+			part[part_num].type=PART_TYPE_FLH;
+			part[part_num].bsize=AKAI_FLH_SIZE;
+		}else{
+			return -1;
+		}
+	}
+	/* Note: now, part[part_num].bsize <= dp->bsize */
+	/* Note: if floppy drive -> open_disk() has set disk type, may differ from partition type */
+
+	/* count free and bad blocks */
+	akai_countfree_part(&part[part_num]);
+
+	/* number of volumes */
+	part[part_num].volnummax=1;
+
+	/* fake partition letter */
+	part[part_num].letter='A';
+
+	part_num++; /* found one */
+
+	return 0;
+}
+
+
+
+int
+akai_scan_harddisk9(struct disk_s *dp)
+{
+	u_int i,n;
+
+	if (dp==NULL){
+		return -1;
+	}
+	
+	/* set disk type */
+	dp->type=DISK_TYPE_HD9;
+
+	/* disk blocksize and total size */
+	if (dp->blksize!=AKAI_HD_BLOCKSIZE){ /* wrong blocksize? */
+		/* set new blksize */
+		dp->blksize=AKAI_HD_BLOCKSIZE;
+		/* disk size in blocks */
+		dp->bsize=dp->totsize/dp->blksize;
+	} /* else: assume that dp->bsize is valid */
+
+	/* disk pointer */
+	part[part_num].diskp=dp;
+
+	part[part_num].valid=1; /* OK so far */
+
+	/* set partition type = disk type */
+	part[part_num].type=dp->type;
+
+	/* fake index on disk */
+	part[part_num].index=0;
+
+	/* block size */
+	part[part_num].blksize=dp->blksize;
+
+	/* start block */
+	part[part_num].bstart=0;
+
+	/* size (Note: also needed to read harddisk header below) */
+	/* first guess: disk size (Note: part[part_num].bstart==0) */
+	part[part_num].bsize=dp->bsize;
+
+	/* try to read S900 harddisk header at block 0 relative to start */
+	if ((part[part_num].bsize<AKAI_HD9HEAD_BLKS)
+		||(akai_io_blks(&part[part_num],(u_char *)&part[part_num].head.hd9,
+						0,
+						AKAI_HD9HEAD_BLKS,
+						1,IO_BLKS_READ)<0)){ /* 1: alloc cache if possible */
+		/* discard this partition, keep old part_num */
+		PRINTF_OUT("disk%u: cannot read S900 harddisk header\n",dp->index);
+		/* assume end of disk, done */
+		return -1;
+	}
+
+	/* start of FAT */
+	part[part_num].fat=&part[part_num].head.hd9.fatblk[0];
+
+	/* count system blocks in FAT */
+	for (i=0;i<AKAI_HD9HEAD_BLKS;i++){
+		n=(part[part_num].fat[i][1]<<8)+part[part_num].fat[i][0];
+		if (n!=AKAI_FAT_CODE_SYS900HD){ /* not reserved for system anymore? */
+			/* discard this partition, keep old part_num */
+			return -1;
+		}
+	}
+
+	/* size */
+	if (part[part_num].head.hd9.flag1==AKAI_HD9FLAG1_SIZEVALID){
+		/* get size from header */
+		part[part_num].bsize=(((u_int)part[part_num].head.hd9.size[1])<<8)
+			+((u_int)part[part_num].head.hd9.size[0]);
+		if (part[part_num].bsize>AKAI_HD9_MAXSIZE){
+			PRINTF_OUT("disk%u: invalid size (0x%04x) of harddisk",
+				dp->index,part[part_num].bsize);
+			part[part_num].bsize=AKAI_HD9_MAXSIZE;
+			PRINTF_OUT(", truncated (0x%04x)\n",part[part_num].bsize);
+			/* XXX keep valid */
+		}
+	}else{
+		/* default size */
+		part[part_num].bsize=AKAI_HD9_DEFSIZE;
+	}
+	/* Note: part[part_num].bstart==0 */
+	if (part[part_num].bsize>dp->bsize){
+		PRINTF_OUT("disk%u: expected size (0x%04x) of harddisk is too large",
+			dp->index,part[part_num].bsize);
+		/* truncate */
+		part[part_num].bsize=dp->bsize;
+		PRINTF_OUT(", truncated (0x%04x)\n",part[part_num].bsize);
+		/* XXX keep valid */
+	}
+
+	/* reserved blocks for system */
+	part[part_num].bsyssize=AKAI_HD9HEAD_BLKS;
+
+	/* count free and bad blocks */
+	akai_countfree_part(&part[part_num]);
+
+	/* number of volumes */
+	part[part_num].volnummax=AKAI_HD9ROOTDIR_ENTRIES;
+
+	/* fake partition letter */
+	part[part_num].letter='A';
+
+	part_num++; /* found one */
+
+	return 0;
+}
+
+
+
+int
+akai_scan_ddpart(struct disk_s *dp,struct akai_parttab_s *ptp,u_int bstart,u_int pi)
+{
+	u_int ptcsize;
+	u_int ptbsize;
+	u_int totsize;
+	u_int di,dimax;
+
+	if ((dp==NULL)||(ptp==NULL)){
+		return -1;
+	}
+	if (bstart>dp->bsize){
+		return -1;
+	}
+
+	/* get number of DD partitions */
+	dimax=ptp->ddpartnum;
+	if (dimax==0){
+		return 0;
+	}
+	if (dimax>AKAI_DDPART_NUM){
+		PRINTF_OUT("disk%u: invalid DD partition number (%u), truncated (%u)\n",
+			dp->index,dimax,AKAI_DDPART_NUM);
+		dimax=AKAI_PART_NUM; /* XXX truncate */
+	}
+
+	totsize=0;
+	for (di=0;(di<dimax)&&(part_num<PART_NUM_MAX);){
+		/* disk pointer */
+		part[part_num].diskp=dp;
+
+		part[part_num].valid=1; /* OK so far */
+
+		/* type */
+		part[part_num].type=PART_TYPE_DD;
+
+		/* index on disk */
+		part[part_num].index=pi;
+
+		/* block size */
+		part[part_num].blksize=dp->blksize;
+
+		/* start block */
+		part[part_num].bstart=bstart;
+
+		/* partition size according to partition table */
+		ptcsize=(ptp->ddpart[di][1]<<8)+ptp->ddpart[di][0]; /* in clusters */
+		ptbsize=ptcsize*AKAI_DDPART_CBLKS; /* in blocks */
+		/* check size */
+		if (ptbsize==0){
+			PRINTF_OUT("disk%u: premature end of DD partitions\n",dp->index);
+			/* end of partitions, done */
+			/* no further partition, keep old part_num */
+			break; /* done */
+		}
+		if (ptbsize>AKAI_HD_MAXSIZE){
+			PRINTF_OUT("disk%u: invalid size (0x%04x) of DD partition %u",
+				dp->index,ptbsize,di);
+			/* truncate */
+			ptbsize=AKAI_HD_MAXSIZE;
+			ptcsize=ptbsize/AKAI_DDPART_CBLKS; /* in clusters */
+			ptbsize=ptcsize*AKAI_DDPART_CBLKS; /* in blocks */
+			PRINTF_OUT(", truncated (0x%04x)\n",ptbsize);
+			/* XXX keep valid */
+		}
+		if ((part[part_num].bstart+ptbsize)>dp->bsize){
+			PRINTF_OUT("disk%u: expected size (0x%04x) of DD partition %u is too large",
+				dp->index,ptbsize,di);
+			/* truncate */
+			if (part[part_num].bstart<dp->bsize){
+				ptbsize=dp->bsize-part[part_num].bstart;
+			}else{
+				ptbsize=0;
+			}
+			ptcsize=ptbsize/AKAI_DDPART_CBLKS; /* in clusters */
+			ptbsize=ptcsize*AKAI_DDPART_CBLKS; /* in blocks */
+			PRINTF_OUT(", truncated (0x%04x)\n",ptbsize);
+			/* XXX keep valid */
+			/* Note: this will be the last DD partition */
+		}
+		part[part_num].bsize=ptbsize;
+		part[part_num].csize=ptcsize;
+
+		/* try to read S1100/S3000 harddisk DD partition header at block 0 relative to start */
+		if ((part[part_num].bsize<AKAI_DDPARTHEAD_BLKS)
+			||(akai_io_blks(&part[part_num],(u_char *)&part[part_num].head.dd,
+							0,
+							AKAI_DDPARTHEAD_BLKS,
+							1,IO_BLKS_READ)<0)){ /* 1: alloc cache if possible */
+			/* discard this partition, keep old part_num */
+			PRINTF_OUT("disk%u: cannot read header of DD partition %u, discarded\n",
+				dp->index,di);
+			break; /* assume end of disk, done */
+		}
+
+		/* start of FAT */
+		part[part_num].fat=&part[part_num].head.dd.fatcl[0];
+
+		/* count free and bad blocks */
+		akai_countfree_part(&part[part_num]);
+
+		/* no volumes */
+		part[part_num].volnummax=0;
+
+		/* fake partition letter */
+		part[part_num].letter=di; /* XXX */
+
+		/* bstart of next DD partition */
+		bstart+=ptbsize;
+		/* update total size of DD partitions */
+		totsize+=ptbsize;
+
+		di++;
+		pi++;
+		part_num++; /* found one */
+
+		if (bstart>=dp->bsize){
+			break; /* done */
+		}
+	}
+
+	/* check total number of DD partitions */
+	if (di!=dimax){
+		PRINTF_OUT("disk%u: inconsistent DD partition number (%u instead of %u), ignored\n",
+			dp->index,di,dimax);
+		/* XXX ignore */
+	}
+
+	/* check total size of DD partitions */
+	/* total size according to partition table */
+	ptcsize=(ptp->ddpart[di][1]<<8)+ptp->ddpart[di][0]; /* in clusters */
+	ptbsize=ptcsize*AKAI_DDPART_CBLKS; /* in blocks */
+	if (ptbsize!=totsize){
+		PRINTF_OUT("disk%u: inconsistent total size of DD partitions (0x%04x instead of 0x%04x), ignored\n",
+			dp->index,totsize,ptbsize);
+		/* XXX ignore */
+	}
+
+	return 0;
+}
+
+
+
+int
+akai_scan_disk(struct disk_s *dp,int floppyenable)
+{
+	u_int bstart;
+	u_int pi,pimax;
+	u_int ptbsize;
+	struct akai_parttab_s *ptp;
+	int retval;
+
+	if (dp==NULL){
+		return -1;
+	}
+	if (dp->totsize==0){
+		PRINTF_OUT("disk%u: zero size\n",dp->index);
+		return -1;
+	}
+
+	/* set disk type */
+	/* first guess: S1000/S3000 harddisk */
+	dp->type=DISK_TYPE_HD;
+
+	/* set disk blocksize */
+	/* first guess: harddisk */
+	/* Note: blksize may change now!!! */
+	dp->blksize=AKAI_HD_BLOCKSIZE;
+
+	/* disk size in blocks */
+	/* Note: uses harddisk blocksize (AKAI_HD_BLOCKSIZE) here */
+	dp->bsize=dp->totsize/dp->blksize;
+	/* Note: dp->bsize can be 0 here */
+
+	/* scan for S1000/S3000 harddisk sampler partitions or S900 harddisk or S900/S1000/S3000 floppy */
+	bstart=0; /* first partition */
+	pimax=AKAI_PART_NUM; /* first guess for number of partitions */
+	ptp=NULL; /* no partition table found so far */
+	for (pi=0;(pi<pimax)&&(part_num<PART_NUM_MAX);){
+		/* Note: possibly scan for S900 harddisk or S900/S1000/S3000 floppy format below => must allow bstart >= dp->bsize here */
+		/* Note: members of current part[part_num] may be overwritten in akai_scan_harddisk9() or akai_scan_floppy() below */
+
+		/* disk pointer */
+		part[part_num].diskp=dp;
+
+		part[part_num].valid=1; /* OK so far */
+
+		/* set partition type = disk type (first guess) */
+		/* Note: DISK_TYPE_HD (==PART_TYPE_HD) here */
+		part[part_num].type=dp->type;
+
+		/* index on disk */
+		part[part_num].index=pi;
+
+		/* block size */
+		/* Note: AKAI_HD_BLOCKSIZE here */
+		part[part_num].blksize=dp->blksize;
+
+		/* start block */
+		part[part_num].bstart=bstart;
+
+		/* partition size (Note: also needed to read sampler partition header below) */
+		/* first guess: max. available size */
+		/* Note: uses harddisk blocksize (AKAI_HD_BLOCKSIZE) here */
+		if (part[part_num].bstart<dp->bsize){
+			part[part_num].bsize=dp->bsize-part[part_num].bstart;
+		}else{
+			part[part_num].bsize=0;
+		}
+
+		/* partition letter */
+		part[part_num].letter='A'+pi;
+
+		/* try to read S1000/S3000 harddisk sampler partition header at block 0 relative to start */
+		if ((part[part_num].bsize<AKAI_PARTHEAD_BLKS)
+			||(akai_io_blks(&part[part_num],(u_char *)&part[part_num].head.hd,
+							0,
+							AKAI_PARTHEAD_BLKS,
+							1,IO_BLKS_READ)<0)){ /* 1: alloc cache if possible */
+			/* not a valid S1000/S3000 harddisk sampler partition */
+			if (pi==0){ /* first partition? */
+				/* scan for S900 harddisk or S900/S1000/S3000 floppy format */
+				goto scan_hd9_floppy;
+			}
+			/* discard this partition, keep old part_num */
+			PRINTF_OUT("disk%u: cannot read header of partition %c, discarded\n",
+				dp->index,part[part_num].letter);
+			break; /* assume end of disk, done */
+		}
+
+		/* sampler partition size (Note: also needed for checksum in magic check below) */
+		/* expected value, will be checked below */
+		part[part_num].bsize=(part[part_num].head.hd.size[1]<<8)+part[part_num].head.hd.size[0];
+
+		/* reserved blocks for system */
+		/* first guess */
+		part[part_num].bsyssize=AKAI_PARTHEAD_BLKS;
+
+		/* number of volumes */
+		/* first guess */
+		part[part_num].volnummax=AKAI_ROOTDIR_ENTRIES;
+
+		/* check magic: indicates S1000/S3000 harddisk sampler partition */
+		if (akai_check_partheadmagic(&part[part_num])<0){
+			/* not a valid S1000/S3000 harddisk sampler partition */
+			if (pi==0){ /* first partition? */
+				/* scan for S900 harddisk or S900/S1000/S3000 floppy format */
+				goto scan_hd9_floppy;
+			}else{
+				PRINTF_OUT("disk%u: invalid format in partition %c, ignored\n",dp->index,'A'+pi);
+				/* XXX invalid, but keep it */
+				part[part_num].valid=0; /* invalid partition so far */
+				/* Note: if non-empty, part_num++ via for-loop */
+			}
+		}
+		/* Note: now, S1000/S3000 harddisk sampler partition */
+
+		/* end of sampler partitions? */
+		if (part[part_num].bsize==0){ /* empty partition? */
+			/* Note: if partition table present, this is a premature end, since pimax should be correct */
+			if (ptp!=NULL){ /* partition table present? */
+				PRINTF_OUT("disk%u: premature end of sampler partitions\n",dp->index);
+				/* XXX ignore */
+			}
+			/* end of sampler partitions, done */
+			/* no further sampler partition, keep old part_num */
+			break; /* done */
+		}
+
+		if (pi==0){ /* first partition? */
+			/* Note: now, first partition header was read and checked */
+
+			/* check magic in parttab: indicates S1000/S3000 harddisk partition table */
+			ptp=&(part[part_num].head.hd.parttab); /* try */
+			if (akai_check_parttabmagic(ptp)==0){
+				/* get number of sampler partitions: first entry in partition table */
+				pimax=ptp->partnum;
+				if (pimax==0){
+					PRINTF_OUT("disk%u: empty partition table, ignored\n",dp->index);
+					pimax=AKAI_PART_NUM; /* XXX try all */
+				}
+				if (pimax>AKAI_PART_NUM){
+					PRINTF_OUT("disk%u: invalid partition number (%u), truncated (%u)\n",
+						dp->index,pimax,AKAI_PART_NUM);
+					pimax=AKAI_PART_NUM; /* XXX truncate */
+				}
+			}else{
+				/* if correct, no partition table present, e.g. for old harddisk format */
+				ptp=NULL;
+				/* XXX nevertheless, try without partition table to find valid partitions */
+				/* XXX no need to mark invalid */
+				PRINTF_OUT("disk%u: no partition table present, ignored\n",dp->index);
+			}
+		}
+
+		if (ptp!=NULL){ /* partition table present? */
+			/* partition size according to partition table */
+			ptbsize=(ptp->part[pi][1]<<8)+ptp->part[pi][0];
+			/* compare */
+			if (part[part_num].bsize!=ptbsize){
+				PRINTF_OUT("disk%u: inconsistent size of partition %c (0x%04x instead of 0x%04x), ignored\n",
+					dp->index,part[part_num].letter,part[part_num].bsize,ptbsize);
+				/* XXX keep valid */
+			}
+		}else{
+			ptbsize=part[part_num].bsize; /* XXX */
+		}
+
+		/* check size */
+		if (part[part_num].bsize>AKAI_PART_MAXSIZE){
+			PRINTF_OUT("disk%u: invalid size (0x%04x) of partition %c",
+				dp->index,part[part_num].bsize,part[part_num].letter);
+			part[part_num].bsize=AKAI_PART_MAXSIZE;
+			PRINTF_OUT(", truncated (0x%04x)\n",part[part_num].bsize);
+			/* XXX keep valid */
+		}
+		if ((part[part_num].bstart+part[part_num].bsize)>dp->bsize){
+			PRINTF_OUT("disk%u: expected size (0x%04x) of partition %c is too large",
+				dp->index,part[part_num].bsize,part[part_num].letter);
+			/* truncate */
+			if (part[part_num].bstart<dp->bsize){
+				part[part_num].bsize=dp->bsize-part[part_num].bstart;
+			}else{
+				part[part_num].bsize=0;
+			}
+			PRINTF_OUT(", truncated (0x%04x)\n",part[part_num].bsize);
+			/* XXX keep valid */
+			/* Note: this will be the last sampler partition */
+		}
+
+		/* start of FAT */
+		part[part_num].fat=&part[part_num].head.hd.fatblk[0];
+
+		/* count free and bad blocks */
+		akai_countfree_part(&part[part_num]);
+
+		/* bstart of next sampler partition */
+		/* XXX trust part[part_num].bsize instead of ptbsize */
+		bstart+=part[part_num].bsize;
+
+		pi++;
+		part_num++; /* found one */
+
+		if (bstart>=dp->bsize){
+			break; /* done */
+		}
+	}
+	/* Note: now, bstart is total size of S1000/S3000 harddisk sampler partitions in blocks */
+
+	if (ptp!=NULL){ /* partition table present? */
+		/* check total number of non-empty sampler partitions */
+		if (pi!=pimax){
+			PRINTF_OUT("disk%u: inconsistent sampler partition number (%u instead of %u), ignored\n",
+				dp->index,pi,pimax);
+			/* XXX ignore */
+		}
+
+		/* check total size of sampler partitions */
+		/* total size according to partition table */
+		ptbsize=(ptp->part[pimax][1]<<8)+ptp->part[pimax][0];
+		if (ptbsize!=bstart){
+			PRINTF_OUT("disk%u: inconsistent total size of sampler partitions (0x%04x instead of 0x%04x), ignored\n",
+				dp->index,bstart,ptbsize);
+			/* XXX ignore */
+		}
+
+		/* scan for S1100/S3000 harddisk DD partitions */
+		akai_scan_ddpart(dp,ptp,bstart,pi); /* Note: ignore possible error */
+	}
+
+	/* Note: valid S1000/S3000 harddisk should have at least one non-empty sampler partition */
+	if (pi==0){
+		PRINTF_OUT("disk%u: invalid format\n",dp->index);
+		return -1;
+	}
+	return 0;
+
+scan_hd9_floppy:
+	/* scan for S900 harddisk or S900/S1000/S3000 floppy format */
+	if ((!floppyenable)||(dp->bsize*dp->blksize>AKAI_FLH_SIZE*AKAI_FL_BLOCKSIZE)){
+		/* scan for S900 harddisk format */
+		/* Note: akai_scan_harddisk9() may overwrite members of current disk and/or part[part_num] if necessary */
+		retval=akai_scan_harddisk9(dp);
+	}else{
+		/* scan for floppy format */
+		/* Note: akai_scan_floppy() may overwrite members of current disk and/or part[part_num] if necessary */
+		/* XXX first blocks with wrong blocksize cached, no problem, will be re-used */
+		retval=akai_scan_floppy(dp);
+	}
+	if (retval<0){
+		PRINTF_OUT("disk%u: invalid format\n",dp->index);
+		/* discard this partition, keep old part_num */
+		/* Note: keep current disk type */
+	}
+	/* assume end of disk, done */
+	return retval;
+}
+
+
+
+int
+akai_wipe_part(struct part_s *pp,int wipeflag,struct part_s *plistp,u_int pimax,int cdromflag)
+{
+	int i;
+	char namebuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	u_int pi,siz;
+	u_int pnum,totb;
+	u_int dnum,totdb;
+
+	/* Note: allow invalid partitions to be wiped!!! */
+	if ((pp==NULL)||(pp->blksize==0)||(pp->diskp==NULL)){
+		return -1;
+	}
+
+	if (pp->type==PART_TYPE_DD){
+		/* S1100/S3000 harddisk DD partition */
+
+		if (wipeflag){
+			static u_char buf[AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE];
+			struct akai_ddparthead_s *hp;
+
+			/* wipe cluster 0: contains partition header */
+			bzero(buf,AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE);
+
+			hp=(struct akai_ddparthead_s *)buf;
+
+			/* mark cluster 0 as reserved for system: contains partition header */
+			hp->fatcl[0][1]=0xff&(AKAI_DDFAT_CODE_SYS>>8);
+			hp->fatcl[0][0]=0xff&(AKAI_DDFAT_CODE_SYS);
+
+			/* update partition header in memory */
+			bcopy(hp,&pp->head.dd,sizeof(struct akai_ddparthead_s));
+
+			/* write cluster 0 */
+			if (akai_io_blks(pp,buf,
+							 0,
+							 AKAI_DDPART_CBLKS, /* 1 cluster */
+							 0,IO_BLKS_WRITE)<0){ /* 0: don't allocate new cache */
+				return -1;
+			}
+		}
+
+		/* count free and bad blocks */
+		akai_countfree_part(pp);
+
+		pp->volnummax=0;
+		pp->valid=1; /* fixed */
+
+		/* Note: no need to exit or restart now */
+		return 0;
+	}
+
+	if ((pp->type==PART_TYPE_HD9)&&(pp->fat!=NULL)){
+		/* S900 harddisk */
+
+		/* number of volumes */
+		pp->volnummax=AKAI_HD9ROOTDIR_ENTRIES;
+
+		if (wipeflag){
+			/* wipe whole header */
+			bzero(&pp->head.hd9,sizeof(struct akai_hd9head_s));
+
+			/* allocate blocks for harddisk header */
+			for (i=0;i<AKAI_HD9HEAD_BLKS;i++){
+				pp->fat[i][1]=0xff&(AKAI_FAT_CODE_SYS900HD>>8);
+				pp->fat[i][0]=0xff&AKAI_FAT_CODE_SYS900HD;
+			}
+		}
+
+		/* set harddisk size */
+		if (pp->bsize>AKAI_HD9_MAXSIZE){
+			pp->bsize=AKAI_HD9_MAXSIZE;
+		}
+		pp->head.hd9.size[1]=0xff&(pp->bsize>>8);
+		pp->head.hd9.size[0]=0xff&pp->bsize;
+		pp->head.hd9.flag1=AKAI_HD9FLAG1_SIZEVALID;
+
+		/* reserved blocks for system */
+		pp->bsyssize=AKAI_HD9HEAD_BLKS;
+
+		/* count free and bad blocks */
+		akai_countfree_part(pp);
+
+		if (wipeflag){
+			/* wipe root directory */
+			bzero(&pp->head.hd9.vol[0],pp->volnummax*sizeof(struct akai_hd9rootdir_entry_s));
+			for (i=0;i<(int)pp->volnummax;i++){
+				/* default volume name */
+				sprintf(namebuf,"VOLUME %03i",i+1);
+				ascii2akai_name(namebuf,pp->head.hd9.vol[i].name,1); /* 1: S900 */
+				pp->head.hd9.vol[i].start[1]=0xff&(AKAI_VOL_START_INACT>>8);
+				pp->head.hd9.vol[i].start[0]=0xff&AKAI_VOL_START_INACT;
+			}
+			/* XXX must erase all vol_s which link to this partition */
+		}
+
+		/* copy first FAT entries */
+		bcopy((u_char *)&pp->head.hd9.fatblk,(u_char *)&pp->head.hd9.fatblk0,AKAI_HD9FAT0_ENTRIES*2);
+		/* write new harddisk header to harddisk */
+		if (akai_io_blks(pp,(u_char *)&pp->head.hd9,
+						 0,
+						 AKAI_HD9HEAD_BLKS,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			return -1;
+		}
+
+		pp->valid=1; /* fixed */
+
+		/* Note: no need to exit or restart now */
+		return 0;
+	}
+
+	if ((pp->type!=PART_TYPE_HD)||(pp->fat==NULL)){
+		return -1;
+	}
+	/* now, S1000/S3000 harddisk sampler partition */
+
+	/* number of volumes */
+	pp->volnummax=AKAI_ROOTDIR_ENTRIES;
+
+	if (wipeflag){
+		/* wipe whole header */
+		bzero(&pp->head.hd,sizeof(struct akai_parthead_s));
+		/* Note: tagsmagic is cleared as well */
+
+		/* allocate blocks for partition header */
+		for (i=0;i<AKAI_PARTHEAD_BLKS;i++){
+			pp->fat[i][1]=0xff&(AKAI_FAT_CODE_SYS>>8);
+			pp->fat[i][0]=0xff&AKAI_FAT_CODE_SYS;
+		}
+
+		if (cdromflag){
+			/* allocate blocks for CD-ROM info */
+			/* XXX minimum size */
+			for (i=AKAI_CDINFO_BLK;i<AKAI_CDINFO_BLK+AKAI_CDINFO_MINSIZB;i++){
+				pp->fat[i][1]=0xff&(AKAI_FAT_CODE_SYS>>8);
+				pp->fat[i][0]=0xff&AKAI_FAT_CODE_SYS;
+			}
+		}
+	}
+
+	/* set partition size */
+	if (pp->bsize>AKAI_PART_MAXSIZE){
+		pp->bsize=AKAI_PART_MAXSIZE;
+	}
+	pp->head.hd.size[1]=0xff&(pp->bsize>>8);
+	pp->head.hd.size[0]=0xff&pp->bsize;
+
+	/* reserved blocks for system */
+	pp->bsyssize=AKAI_PARTHEAD_BLKS;
+
+	/* count free and bad blocks */
+	akai_countfree_part(pp);
+
+	/* fix magic: indicates harddisk */
+	akai_fix_partheadmagic(pp);
+
+	if (wipeflag){
+		/* wipe root directory */
+		bzero(&pp->head.hd.vol[0],pp->volnummax*sizeof(struct akai_rootdir_entry_s));
+		for (i=0;i<(int)pp->volnummax;i++){
+			/* default volume name */
+			sprintf(namebuf,"VOLUME %03i",i+1);
+			ascii2akai_name(namebuf,pp->head.hd.vol[i].name,0); /* 0: not S900 */
+			pp->head.hd.vol[i].type=AKAI_VOL_TYPE_INACT;
+		}
+		/* XXX must erase all vol_s which link to this partition */
+	}
+
+	/* first partition on disk and want to fix partition table? */
+	if ((pp->index==0)&&(plistp!=NULL)){
+		/* initialize partition table */
+		bzero(&(pp->head.hd.parttab),sizeof(struct akai_parttab_s));
+
+		/* fix parttab magic: indicates partition table */
+		akai_fix_parttabmagic(&(pp->head.hd.parttab));
+
+		/* count number of partitions on same disk */
+		pnum=0;
+		totb=0;
+		dnum=0;
+		totdb=0;
+		for (pi=0;pi<pimax;pi++){
+			if ((plistp[pi].diskp!=NULL)&&(plistp[pi].diskp->fd==pp->diskp->fd)){ /* same disk? */
+				if (plistp[pi].type==PART_TYPE_DD){
+					/* S1100/S3000 harddisk DD partition */
+					if (dnum>=AKAI_DDPART_NUM){ /* already enough and another one? */
+						PRINTF_OUT("too many DD partitions on disk, truncated\n");
+						continue; /* next */
+					}
+					siz=plistp[pi].bsize/AKAI_DDPART_CBLKS; /* XXX round down */
+					/* set partition size in partition table */
+					pp->head.hd.parttab.ddpart[dnum][1]=0xff&(siz>>8);
+					pp->head.hd.parttab.ddpart[dnum][0]=0xff&siz;
+					/* accumulate total size */
+					totdb+=siz;
+					dnum++; /* found one */
+				}else{
+					if (pnum>=AKAI_PART_NUM){ /* already enough and another one? */
+						PRINTF_OUT("too many partitions on disk, truncated\n");
+						continue; /* next */
+					}
+					siz=plistp[pi].bsize;
+					/* set partition size in partition table */
+					pp->head.hd.parttab.part[pnum][1]=0xff&(siz>>8);
+					pp->head.hd.parttab.part[pnum][0]=0xff&siz;
+					/* accumulate total size */
+					totb+=siz;
+					pnum++; /* found one */
+				}
+			}
+		}
+
+		/* set partition number */
+		pp->head.hd.parttab.partnum=0xff&pnum;
+		/* append total size at end of table */
+		/* Note: pnum has been checked above */
+		pp->head.hd.parttab.part[pnum][1]=0xff&(totb>>8);
+		pp->head.hd.parttab.part[pnum][0]=0xff&totb;
+
+		/* set DD partition number */
+		pp->head.hd.parttab.ddpartnum=0xff&dnum;
+		/* append total size at end of DD table */
+		/* Note: dnum has been checked above */
+		pp->head.hd.parttab.ddpart[dnum][1]=0xff&(totdb>>8);
+		pp->head.hd.parttab.ddpart[dnum][0]=0xff&totdb;
+	}
+
+	/* write new partition header to partition */
+	if (akai_io_blks(pp,(u_char *)&pp->head.hd,
+					 0,
+					 AKAI_PARTHEAD_BLKS,
+					 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+		return -1;
+	}
+
+	if (cdromflag){
+		static u_char buf[AKAI_CDINFO_MINSIZB*AKAI_HD_BLOCKSIZE]; /* XXX minimum size */
+		struct akai_cdinfohead_s *p;
+
+		/* wipe CD-ROM info */
+		/* XXX minimum size */
+		bzero(buf,AKAI_CDINFO_MINSIZB*AKAI_HD_BLOCKSIZE);
+		p=(struct akai_cdinfohead_s *)buf;
+		/* default label */
+		/* Note: CD-ROM label uses S1000/S3000 char conversion */
+		ascii2akai_name(AKAI_CDINFO_DEFLABEL,p->cdlabel,0); /* 0: not S900 */
+		if (akai_io_blks(pp,buf,
+						 AKAI_CDINFO_BLK,
+						 AKAI_CDINFO_MINSIZB,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			return -1;
+		}
+	}
+
+	pp->valid=1; /* fixed */
+
+	/* Note: no need to exit or restart now */
+	return 0;
+}
+
+
+
+/* Note: blksize might change, must flush prior to formatting!!! */
+/* Note: overwrites part[] */
+/* Note: must flush cache and exit (or restart) if return value >=0 !!! */
+int
+akai_wipe_harddisk(struct disk_s *dp,u_int bsize,u_int totb,int s3000flag,int cdromflag)
+{
+	u_int pi,pimax;
+	u_int bc,bremain,bchunk,bmin;
+
+	if (dp==NULL){
+		return -1;
+	}
+
+	/* S1000/S3000 harddisk */
+
+	if (totb*AKAI_HD_BLOCKSIZE>dp->bsize*dp->blksize){
+		totb=(dp->bsize*dp->blksize)/AKAI_HD_BLOCKSIZE; /* truncate */
+	}
+	if (totb>AKAI_HD_MAXSIZE){
+		totb=AKAI_HD_MAXSIZE; /* truncate */
+	}
+	if (bsize>totb){
+		bsize=totb; /* truncate */
+	}
+	if (bsize>AKAI_PART_MAXSIZE){
+		bsize=AKAI_PART_MAXSIZE; /* truncate */
+	}
+	if (bsize<AKAI_PARTHEAD_BLKS){
+		PRINTF_ERR("invalid partition size\n");
+		return -1;
+	}
+
+	/* set disk blocksize */
+	dp->blksize=AKAI_HD_BLOCKSIZE;
+	/* disk size in blocks */
+	dp->bsize=dp->totsize/dp->blksize;
+
+	/* minimum harddisk sampler partition size */
+	if (cdromflag){
+		/* with min. CD-ROM info behind header */
+		bmin=AKAI_PARTHEAD_BLKS+AKAI_CDINFO_MINSIZB;
+	}else{
+		bmin=AKAI_PARTHEAD_BLKS;
+	}
+
+	/* Note: overwrite part[] */
+	bremain=totb;
+	bc=0; /* block counter */
+	for (pi=0;(pi<AKAI_PART_NUM)&&(pi<PART_NUM_MAX);){
+		if (bremain>bsize){
+			bchunk=bsize;
+		}else{
+			bchunk=bremain;
+		}
+		if (bchunk<bmin){
+			/* not enough for harddisk sampler partition */
+			break; /* done */
+		}
+
+		/* initialize partition */
+		part[pi].diskp=dp;
+		part[pi].valid=1;
+		part[pi].type=PART_TYPE_HD;
+		part[pi].index=pi;
+		part[pi].blksize=dp->blksize;
+		part[pi].bstart=bc;
+		part[pi].bsize=bchunk;
+		part[pi].bsyssize=AKAI_PARTHEAD_BLKS;
+		part[pi].fat=&part[pi].head.hd.fatblk[0];
+		part[pi].volnummax=AKAI_ROOTDIR_ENTRIES;
+		part[pi].letter='A'+pi;
+
+		pi++; /* created one */
+
+		bremain-=bchunk;
+		bc+=bchunk;
+		if (bremain==0){
+			break; /* done */
+		}
+	}
+
+	if (pi==0){
+		PRINTF_OUT("no partitions created\n");
+		return 0;
+	}
+
+	/* space for DD */
+	/* XXX check totb alignment to AKAI_DDPART_BLKS granularity */
+	bremain=dp->bsize-totb;
+	/* fix size */
+	bremain/=AKAI_DDPART_CBLKS; /* round down */
+	if (bremain>0){
+		bremain--; /* XXX */
+	}
+	bremain*=AKAI_DDPART_CBLKS;
+	if ((pi<PART_NUM_MAX)&&(bremain>0)){ /* space for DD left at end of disk? */
+		PRINTF_OUT("0x%04x blocks for DD at end of disk\n",bremain);
+		/* initialize one DD partition at end of disk */
+		part[pi].diskp=dp;
+		part[pi].valid=1;
+		part[pi].type=PART_TYPE_DD;
+		part[pi].index=pi;
+		part[pi].blksize=dp->blksize;
+		part[pi].bstart=totb;
+		part[pi].bsize=bremain;
+		part[pi].csize=bremain/AKAI_DDPART_CBLKS;
+		part[pi].fat=NULL;
+		part[pi].volnummax=0;
+		part[pi].letter=0;
+
+		pi++; /* created one */
+	}
+
+	/* now, all partitions known for partition table */
+	pimax=pi;
+	for (pi=0;pi<pimax;pi++){
+		/* wipe partition */
+		if (akai_wipe_part(&part[pi],1,&part[0],pimax,cdromflag)<0){ /* 1: wipe */
+			if (part[pi].type==PART_TYPE_DD){
+				if (part[pi].letter==0){
+					PRINTF_ERR("cannot wipe partition DD\n");
+				}else{
+					PRINTF_ERR("cannot wipe partition DD%u\n",(u_int)part[pi].letter);
+				}
+			}else{
+				PRINTF_ERR("cannot wipe partition %c\n",part[pi].letter);
+			}
+			return 1; /* fatal */
+		}
+		if ((part[pi].type==PART_TYPE_HD)&&s3000flag){
+			if (akai_rename_tag(&part[pi],NULL,0,1)<0){ /* 1: wipe */
+				PRINTF_ERR("cannot initialize tags in partition %c\n",part[pi].letter);
+				/* XXX ignore error */
+			}
+		}
+#if 0 /* Note: must exit (or restart) anyway, no need to count free and bad blocks here */
+		akai_countfree_part(&part[pi]);
+#endif
+	}
+
+	PRINTF_OUT("created %u partition(s)\n",pimax);
+	return 0;
+}
+
+
+
+/* Note: blksize might change, must flush prior to formatting!!! */
+/* Note: overwrites part[] */
+/* Note: must flush cache and exit (or restart) if return value >=0 !!! */
+int
+akai_wipe_harddisk9(struct disk_s *dp,u_int totb)
+{
+
+	if (dp==NULL){
+		return -1;
+	}
+
+	/* S900 harddisk */
+
+	/* Note: overwrite part[] */
+	if (PART_NUM_MAX<1){
+		PRINTF_ERR("not enough partition space allocated\n");
+		return -1;
+	}
+
+	if (totb*AKAI_HD_BLOCKSIZE>dp->bsize*dp->blksize){
+		totb=(dp->bsize*dp->blksize)/AKAI_HD_BLOCKSIZE; /* truncate */
+	}
+	if (totb>AKAI_HD9_MAXSIZE){
+		totb=AKAI_HD9_MAXSIZE; /* truncate */
+	}
+	if (totb<AKAI_HD9HEAD_BLKS){
+		PRINTF_ERR("invalid size\n");
+		return -1;
+	}
+
+	/* set disk blocksize */
+	dp->blksize=AKAI_HD_BLOCKSIZE;
+	/* disk size in blocks */
+	dp->bsize=dp->totsize/dp->blksize;
+
+	/* Note: overwrite part[] */
+	/* initialize partition */
+	part[0].diskp=dp;
+	part[0].valid=1;
+	part[0].type=PART_TYPE_HD9;
+	part[0].index=0;
+	part[0].blksize=dp->blksize;
+	part[0].bstart=0;
+	part[0].bsize=totb;
+	part[0].bsyssize=AKAI_HD9HEAD_BLKS;
+	part[0].fat=&part[0].head.hd9.fatblk[0];
+	part[0].volnummax=AKAI_HD9ROOTDIR_ENTRIES;
+	part[0].letter='A'; /* fake partition letter */
+
+	/* wipe partition */
+	if (akai_wipe_part(&part[0],1,NULL,0,0)<0){ /* 1: wipe */
+		return 1; /* fatal */
+	}
+
+#if 0 /* Note: must exit (or restart) anyway, no need to count free and bad blocks here */
+	akai_countfree_part(&part[0]);
+#endif
+
+	return 0;
+}
+
+
+
+/* Note: blksize might change, must flush prior to formatting!!! */
+/* Note: overwrites part[] */
+/* Note: must flush cache and exit (or restart) if return value >=0 !!! */
+int
+akai_wipe_floppy(struct disk_s *dp,int lodensflag,int s3000flag,int s900flag)
+{
+	struct akai_voldir3000fl_s tmpdir3000;
+	struct akai_flvol_label_s *lp;
+	u_int hdsiz;
+	u_int voldir3000bstart;
+	u_int i,imax;
+	u_int osver;
+	u_int fatcodesys;
+
+	if (dp==NULL){
+		return -1;
+	}
+
+	/* floppy */
+
+	/* Note: overwrite part[] */
+	if (PART_NUM_MAX<1){
+		PRINTF_ERR("not enough partition space allocated\n");
+		return -1;
+	}
+
+	if (((!lodensflag)&&(dp->bsize*dp->blksize<AKAI_FLH_SIZE*AKAI_FL_BLOCKSIZE))
+		||((lodensflag)&&(dp->bsize*dp->blksize<AKAI_FLL_SIZE*AKAI_FL_BLOCKSIZE))){
+		PRINTF_ERR("invalid disk size\n");
+		return -1;
+	}
+
+	/* set disk blocksize */
+	dp->blksize=AKAI_FL_BLOCKSIZE;
+	/* disk size in blocks */
+	dp->bsize=dp->totsize/dp->blksize;
+
+	/* floppy header */
+	if (lodensflag){
+		lp=&part[0].head.fll.label;
+		hdsiz=AKAI_FLLHEAD_BLKS;
+		voldir3000bstart=AKAI_VOLDIR3000FLL_BSTART; /* for S3000 */
+	}else{
+		lp=&part[0].head.flh.label;
+		hdsiz=AKAI_FLHHEAD_BLKS;
+		voldir3000bstart=AKAI_VOLDIR3000FLH_BSTART; /* for S3000 */
+	}
+	/* Note: low- and high-density floppy headers are identical */
+	/*       up to first AKAI_FAT_ENTRIES_FLL FAT-entries */
+	/* => set files and system blocks in FAT in high-density header */
+
+	/* initialize partition */
+	part[0].diskp=dp;
+	part[0].valid=1;
+	if (lodensflag){
+		part[0].type=PART_TYPE_FLL;
+	}else{
+		part[0].type=PART_TYPE_FLH;
+	}
+	part[0].index=0;
+	part[0].blksize=dp->blksize;
+	part[0].bstart=0;
+	if (lodensflag){
+		part[0].bsize=AKAI_FLL_SIZE;
+	}else{
+		part[0].bsize=AKAI_FLH_SIZE;
+	}
+	/* Note: see comment above: FAT-start same for low- and high density */
+	part[0].fat=&part[0].head.flh.fatblk[0];
+
+	/* number of volumes */
+	part[0].volnummax=1;
+
+	/* fake partition letter */
+	part[0].letter='A';
+
+	/* wipe floppy header */
+	/* Note: high-density floppy header enough, also for low-density floppy case */
+	bzero(&part[0].head.flh,sizeof(struct akai_flhhead_s));
+
+	/* OS version */
+	if (s3000flag){
+		/* S3000 */
+		osver=AKAI_OSVER_S3000MAX; /* XXX */
+	}else if (s900flag){
+		/* S900 */
+		osver=AKAI_OSVER_S900VOL;
+	}else{
+		/* S1000 */
+		osver=AKAI_OSVER_S1000MAX; /* XXX */
+	}
+	lp->osver[1]=0xff&(osver>>8);
+	lp->osver[0]=0xff&osver;
+
+	/* wipe S900/S1000 volume directory */
+	for (i=0;i<AKAI_VOLDIR_ENTRIES_S1000FL;i++){
+		akai_fvol1000_initfile(&part[0].head.flh.file[i],osver,
+							   s3000flag?AKAI_FILE_TAGFREE:AKAI_FILE_TAGS1000);
+	}
+	if (s3000flag){
+		/* mark S3000 floppy */
+		part[0].head.flh.file[0].type=AKAI_VOLDIR3000FL_FTYPE;
+	}
+
+	if (!s900flag){
+		/* S1000/S3000 */
+
+		/* default volume name */
+		ascii2akai_name("NOT NAMED   ",lp->name,0); /* 0: not S900 */
+
+		/* default volume parameters */
+		akai_init_volparam(&lp->param,s3000flag);
+	}
+
+	/* allocate blocks in FAT */
+	if (s900flag){
+		/* S900 */
+		fatcodesys=AKAI_FAT_CODE_SYS900FL;
+	}else{
+		/* S1000/S3000 */
+		fatcodesys=AKAI_FAT_CODE_SYS;
+	}
+	imax=hdsiz; /* floppy header */
+	if (s3000flag){
+		/* S3000 volume directory is directly behind floppy header */
+		imax+=AKAI_VOLDIR3000FL_BLKS;
+	}
+	for (i=0;i<imax;i++){
+		part[0].fat[i][1]=0xff&(fatcodesys>>8);
+		part[0].fat[i][0]=0xff&fatcodesys;
+	}
+	/* reserved blocks for system */
+	part[0].bsyssize=imax;
+
+	/* write floppy header */
+	if (akai_io_blks(&part[0],(u_char *)&part[0].head.flh,
+					 0,
+					 hdsiz,
+					 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+		return 1; /* fatal */
+	}
+
+	if (s3000flag){
+		/* wipe S3000 volume directory */
+		bzero(&tmpdir3000,sizeof(struct akai_voldir3000fl_s));
+		for (i=0;i<AKAI_VOLDIR_ENTRIES_S3000FL;i++){
+			tmpdir3000.file[i].type=AKAI_FTYPE_FREE;
+		}
+
+		/* write S3000 volume directory */
+		if (akai_io_blks(&part[0],(u_char *)&tmpdir3000,
+						 voldir3000bstart,
+						 AKAI_VOLDIR3000FL_BLKS,
+						 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+			return 1; /* fatal */
+		}
+	}
+
+#if 0 /* Note: must exit (or restart) anyway, no need to count free and bad blocks here */
+	akai_countfree_part(&part[0]);
+#endif
+
+	return 0;
+}
+
+
+
+/* XXX no check for recursion overflow */
+int
+change_curdir(char *name,u_int vi,char *lastname,int checklast)
+{
+	/* Note: variables below must be auto, for recursion!!! */
+	char namebuf[DIRNAMEBUF_LEN+1]; /* +1 for '\0' */
+	u_int l;
+	u_int i;
+	int j;
+	char *np0,*np1;
+	struct disk_s *tmpcurdiskp;
+	struct part_s *tmpcurpartp;
+	struct vol_s *tmpcurvolp;
+	struct vol_s tmpcurvol_buf; /* change_curdir does not modify directories => OK to save and restore buffer */
+	int ret;
+
+	/* save state, needed in case of error */
+	tmpcurdiskp=curdiskp;
+	tmpcurpartp=curpartp;
+	tmpcurvolp=curvolp;
+	if (curvolp!=NULL){ /* need to save? */
+		tmpcurvol_buf=*curvolp; /* !!! */
+		/* Note: save original, to be restored later on, copy not to be used!!! */
+	}
+
+	ret=0; /* no error so far */
+	np0=namebuf; /* first token */
+	np1=NULL; /* no recursion so far */
+
+	if (name==NULL){
+		/* must be in partition */
+		if ((curpartp==NULL)||(curvolp!=NULL)){
+			ret=-1;
+			goto change_curdir_done;
+		}
+		/* user-supplied volume index */
+		if (vi>=curpartp->volnummax){
+			ret=-1;
+			goto change_curdir_done;
+		}
+		if (akai_get_vol(curpartp,&curvol_buf,vi)<0){ /* not found? */
+			ret=-1;
+			goto change_curdir_done;
+		}
+		curvolp=&curvol_buf;
+		goto change_curdir_done;
+	}
+
+	/* copy name for possible manupulation */
+	strncpy(namebuf,name,DIRNAMEBUF_LEN);
+	namebuf[DIRNAMEBUF_LEN]='\0'; /* just in case */
+
+	/* check if absolute path */
+	if (np0[0]=='/'){
+		/* goto system level */
+		curdiskp=NULL;
+		curpartp=NULL;
+		curvolp=NULL;
+		np0++; /* '\0' in worst case */
+	}
+	l=(u_int)strlen(np0);
+
+	/* search first delimiter */
+	for (i=0;i<l;i++){
+		if (np0[i]=='/'){
+			break;
+		}
+	}
+	if (i<l){ /* found one? */
+		/* separate strings */
+		np0[i]='\0';
+		np1=&np0[i+1]; /* '\0' in worst case, since i<l */
+		/* Note: np1 must not be absolute path again!!! */
+		if (np1[0]=='/'){ /* first char again delimiter? */
+			ret=-1;
+			goto change_curdir_done;
+		}
+		/* take care of np1 below */
+	}
+	/* now, np0 contains only one hirarchy level, but not the last one if np1!=NULL */
+
+	if ((np1==NULL)&&(lastname!=NULL)){ /* is last hirarchy level and want to extract it? */
+		/* Note: in particular if l==0, we end up here (for lastname!=NULL) */
+		/* XXX no overflow check in strcpy */
+		strcpy(lastname,np0);
+		goto change_curdir_done;
+	}
+	/* Note: checklast irrelevant if lastname!=NULL */
+
+	/* now, change current directory */
+
+	if (l==0){
+		/* Note: we do not search for disk, partition, or volume with empty name */
+		/* nothing to do */
+		goto change_curdir_done; /* done */
+	}
+
+	if (strcmp(np0,".")==0){
+		/* nothing to do */
+		goto change_curdir_done;
+	}
+
+	if (strcmp(np0,"..")==0){
+		/* one level up */
+		if (curdiskp==NULL){
+			/* nothing to do */
+			goto change_curdir_done;
+		}
+		if (curpartp==NULL){
+			curdiskp=NULL;
+			goto change_curdir_done;
+		}
+		if (curvolp==NULL){
+			curpartp=NULL;
+			goto change_curdir_done;
+		}
+		curvolp=NULL;
+		goto change_curdir_done;
+	}
+
+	if (curdiskp==NULL){
+#if 1
+		if (strncasecmp(np0,"floppy",6)==0){
+			np0+=6;
+			/* find floppy */
+			if (strlen(np0)==0){ /* empty? */
+				/* "/floppy" -> "/disk0/A/<volume1>" */
+				j=0; /* disk0 */
+			}else{
+				/* "/floppyN" -> "/diskN/A/<volume1>" */
+				j=atoi(np0);
+			}
+			/* find disk */
+			if ((j<0)||(j>=(int)disk_num)){
+				PRINTF_ERR("invalid disk\n");
+				ret=-1;
+				goto change_curdir_done;
+			}
+			curdiskp=&disk[j];
+			/* find partition */
+			curpartp=akai_find_part(curdiskp,"A");
+			if (curpartp==NULL){ /* not found? */
+				ret=-1;
+				goto change_curdir_done;
+			}
+			if ((np1!=NULL)||checklast){ /* not last or need to check last? */
+				if (!curpartp->valid){
+					PRINTF_ERR("invalid partition\n");
+					ret=-1;
+					goto change_curdir_done;
+				}
+				if ((curpartp->type!=PART_TYPE_FLL)&&(curpartp->type!=PART_TYPE_FLH)){
+					PRINTF_OUT("disk%i is not a floppy\n",j);
+					ret=-1;
+					goto change_curdir_done;
+				}
+			}
+			/* get volume1 (volume index 0) */
+			if (akai_get_vol(curpartp,&curvol_buf,0)<0){ /* not found? */
+				PRINTF_ERR("invalid volume\n");
+				ret=-1;
+				goto change_curdir_done;
+			}
+			curvolp=&curvol_buf; /* only this one!!! */
+			goto change_curdir_done;
+		}
+#endif
+		/* find disk */
+		if (strncasecmp(np0,"disk",4)==0){
+			np0+=4;
+		}
+		if (strlen(np0)==0){ /* empty? */
+			ret=-1;
+			goto change_curdir_done;
+		}
+		j=atoi(np0);
+		if ((j<0)||(j>=(int)disk_num)){
+			PRINTF_ERR("invalid disk\n");
+			ret=-1;
+			goto change_curdir_done;
+		}
+		curdiskp=&disk[j];
+		goto change_curdir_done;
+	}
+
+	if (curpartp==NULL){
+		/* find partition */
+		curpartp=akai_find_part(curdiskp,np0);
+		if (curpartp==NULL){ /* not found? */
+			ret=-1;
+			goto change_curdir_done;
+		}
+		if ((np1!=NULL)||checklast){ /* not last or need to check last? */
+			if (!curpartp->valid){
+				PRINTF_ERR("invalid partition\n");
+				ret=-1;
+				goto change_curdir_done;
+			}
+		}
+		goto change_curdir_done;
+	}
+
+	if (curvolp==NULL){
+		if (curpartp->type==PART_TYPE_DD){
+			PRINTF_OUT("no volumes in DD partition\n");
+			ret=-1;
+			goto change_curdir_done;
+		}
+		/* find volume */
+		if (akai_find_vol(curpartp,&curvol_buf,np0)<0){ /* not found? */
+			ret=-1;
+			goto change_curdir_done;
+		}
+		/* Note: akai_find_volume has checked for AKAI_VOL_TYPE_INACT */
+		curvolp=&curvol_buf; /* only this one!!! */
+		goto change_curdir_done;
+	}
+
+	/* no further directories */
+	ret=-1;
+	goto change_curdir_done;
+
+change_curdir_done:
+	if ((ret==0)&&(np1!=NULL)){ /* recursion requested? */
+		ret=change_curdir(np1,vi,lastname,checklast); /* recursion */
+	}
+	if (ret<0){
+		/* error, must restore state */
+		curdiskp=tmpcurdiskp;
+		curpartp=tmpcurpartp;
+		curvolp=tmpcurvolp;
+		if (curvolp!=NULL){ /* was saved? */
+			*curvolp=tmpcurvol_buf; /* !!! */
+			/* Note: restore orginal from copy!!! */
+		}
+	}
+	return ret;
+}
+
+int
+change_curdir_home(void)
+{
+
+	/* goto system level */
+	curdiskp=NULL;
+	curpartp=NULL;
+	curvolp=NULL;
+
+	if (disk_num==1){
+		/* goto first disk */
+		curdiskp=&disk[0];
+
+		if ((part_num==1)&&part[0].valid){
+			if (((part[0].type==PART_TYPE_FLL)||(part[0].type==PART_TYPE_FLH))){
+				/* goto floppy volume */
+				return change_curdir("/floppy",0,NULL,1); /* NULL,1: check last */
+			}else if (part[0].type==PART_TYPE_HD9){
+				/* goto fake partition A */
+				return change_curdir("A",0,NULL,1); /* NULL,1: check last */
+			}
+		}
+	}
+
+	return 0;
+}
+
+
+
+void
+save_curdir(int modflag)
+{
+
+	savecurdiskp=curdiskp;
+	savecurpartp=curpartp;
+	savecurvolp=curvolp;
+	if (!modflag){
+		/* will not modify volumes => OK to save and restore buffer */
+		savecurvol_buf=curvol_buf;
+	}else{
+		/* save name */
+		if (curvolp!=NULL){
+			strcpy(savecurvolname,curvolp->name);
+			/* save index for case of empty volume name */
+			savecurvolindex=curvolp->index;
+		}
+	}
+	savecurvolmodflag=modflag;
+}
+
+void
+restore_curdir(void)
+{
+	char *np;
+
+	 /* Note: OS keeps track of changes, no need to reload */
+	curdiskp=savecurdiskp;
+
+	/* Note: part[] keeps track of changes, no need to reload */
+	curpartp=savecurpartp;
+	if ((curpartp!=NULL)&&(curpartp->valid==0)){
+		/* could happen */
+		/* goto disk */
+		curpartp=NULL;
+		savecurvolp=NULL;
+		savecurvolmodflag=0;
+		PRINTF_OUT("partition has changed, now in upper disk\n");
+		/* XXX just stay in partition */
+	}
+
+	/* Note: only one volume buffer, saved contents might be out-of-date (e.g. rename, delete, create)!!! */
+	curvolp=savecurvolp;
+	if (!savecurvolmodflag){
+		/* has not modified volumes => OK to save and restore buffer */
+		curvol_buf=savecurvol_buf;
+	}else{
+		/* volume buffer could be out-of-date, must reload */
+		if (curvolp!=NULL){
+			curvolp=NULL; /* goto partition */
+			if (savecurvolname[0]=='\0'){ /* empty volume name? */
+				np=NULL; /* => change_curdir() below will use savecurvolindex */
+			}else{
+				np=savecurvolname; /* => change_curdir() below will use savecurvolname */
+			}
+			if (change_curdir(np,savecurvolindex,NULL,1)<0){ /* 1: check */
+				/* could happen */
+				PRINTF_OUT("volume has changed, now in upper partition\n");
+				/* XXX just stay in partition */
+			}
+		}
+	}
+}
+
+
+
+void
+curdir_info(int verbose,char *pathbuf)
+{
+	static char tmppathbuf[DIRNAMEBUF_LEN+1]; /* +1 for '\0' */
+	int pathprintflag;
+	u_int pathlen;
+	struct vol_s tmpvol;
+	u_int vi;
+	u_int ai;
+
+	if (pathbuf==NULL){
+		pathbuf=tmppathbuf;
+		pathprintflag=1;
+	}else{
+		pathprintflag=verbose;
+	}
+	sprintf(pathbuf,"/");
+	if (curdiskp!=NULL){
+		pathlen=1;
+		sprintf(pathbuf+pathlen,"disk%u",curdiskp->index);
+		if (curpartp!=NULL){
+			pathlen=(u_int)strlen(pathbuf);
+			if (curpartp->type==PART_TYPE_DD){
+				if (curpartp->letter==0){
+					sprintf(pathbuf+pathlen,"/DD");
+				}else{
+					sprintf(pathbuf+pathlen,"/DD%u",(u_int)curpartp->letter);
+				}
+			}else{
+				sprintf(pathbuf+pathlen,"/%c",curpartp->letter);
+			}
+			if (curvolp!=NULL){
+				pathlen=(u_int)strlen(pathbuf);
+				sprintf(pathbuf+pathlen,"/%s",curvolp->name);
+			}
+		}
+	}
+	if (pathprintflag){
+		PRINTF_OUT("%s",pathbuf);
+	}
+
+	if (verbose){
+		PRINTF_OUT("\n");
+		if (curvolp!=NULL){
+			ai=0; /* volume alias number unknown */
+			if ((curpartp!=NULL)&&(curpartp->type==PART_TYPE_HD9)){
+				/* S900 harddisk */
+				/* determine volume alias number */
+				ai=1; /* start number */
+				/* add number of active volumes in partition before current volume */
+				for (vi=0;(vi<curvolp->index)&&(vi<curpartp->volnummax);vi++){
+					/* try to get volume */
+					if (akai_get_vol(curpartp,&tmpvol,vi)<0){
+						continue; /* next volume */
+					}
+					ai++; /* one more active volume */
+				}
+			}
+			akai_vol_info(curvolp,ai,1); /* 1: verbose */
+		}else if (curpartp!=NULL){
+			akai_part_info(curpartp,1); /* 1: verbose */
+		}else if (curdiskp!=NULL){
+			akai_disk_info(curdiskp,1); /* 1: verbose */
+		}else{
+			PRINTF_OUT("disks: %u\n",disk_num);
+		}
+	}
+}
+
+void
+list_curdir(int recflag)
+{
+
+	if (curdiskp==NULL){
+		akai_list_alldisks(recflag,curfiltertag);
+		return;
+	}
+
+	if (curpartp==NULL){
+		akai_list_disk(curdiskp,recflag,curfiltertag);
+		return;
+	}
+
+	if (curvolp==NULL){
+		akai_list_part(curpartp,recflag,curfiltertag);
+		return;
+	}
+
+	akai_list_vol(curvolp,curfiltertag);
+}
+
+
+
+void
+list_curfiltertags(void)
+{
+	u_int i;
+	u_int noneflag;
+
+	PRINTF_OUT("filter tags: ");
+	noneflag=1; /* none so far */
+	for (i=0;i<AKAI_FILE_TAGNUM;i++){
+		if ((curfiltertag[i]!=AKAI_FILE_TAGFREE)&&(curfiltertag[i]!=AKAI_FILE_TAGS1000)){ /* not free? */
+			PRINTF_OUT("%02u ",curfiltertag[i]);
+			noneflag=0;
+		}
+	}
+	if (noneflag){
+		PRINTF_OUT("none");
+	}
+	PRINTF_OUT("\n");
+}
+
+
+
+int
+copy_file(struct file_s *srcfp,struct vol_s *dstvp,struct file_s *dstfp,u_int dstindex,char *dstname,int delflag)
+{
+	struct file_s tmpfile;
+	u_char *tmpbuf;
+	int existsflag;
+
+	if ((srcfp==NULL)||(dstvp==NULL)){
+		return -1;
+	}
+
+	if (dstname==NULL){ /* no user-supplied name? */
+		dstname=srcfp->name;
+	}
+
+	/* allocate buffer */
+	if ((tmpbuf=(u_char *)malloc(srcfp->size))==NULL){
+		PERROR("malloc");
+		return -1;
+	}
+
+	/* check if destination file already exists */
+	existsflag=0;
+	if (dstindex==AKAI_CREATE_FILE_NOINDEX){ /* no user-supplied index? */
+		/* check if file name already used in destination volume */
+		if (akai_find_file(dstvp,&tmpfile,dstname)==0){
+			existsflag=1;
+		}
+	}else{
+		/* check if file with given index already exists in destination volume */
+		if (akai_get_file(dstvp,&tmpfile,dstindex)==0){
+			existsflag=1;
+		}
+	}
+	if (existsflag){
+		/* same file? Note: same partition and same block should be unique */
+		if ((srcfp->volp->partp==tmpfile.volp->partp)&&(srcfp->bstart==tmpfile.bstart)){
+			PRINTF_ERR("cannot copy to same file\n");
+			free(tmpbuf);
+			return -1;
+		}
+		/* exists */
+		if (delflag){
+			/* delete file */
+			if (akai_delete_file(&tmpfile)<0){
+				PRINTF_ERR("cannot overwrite existing file\n");
+				free(tmpbuf);
+				return -1;
+			}
+		}else{
+			PRINTF_OUT("file name already used\n");
+			free(tmpbuf);
+			return -1;
+		}
+	}
+
+	/* create file */
+	/* Note: akai_create_file() will correct osver if necessary */
+	if (akai_create_file(dstvp,&tmpfile,srcfp->size,dstindex,dstname,
+						 srcfp->osver, /* default: from source file */
+						 (srcfp->volp->type==AKAI_VOL_TYPE_S900)?NULL:srcfp->tag)<0){ /* no tags from S900 */
+		PRINTF_ERR("cannot create file\n");
+		free(tmpbuf);
+		return -1;
+	}
+
+	if (dstfp!=NULL){
+		/* copy for information */
+		*dstfp=tmpfile;
+	}
+
+	/* read file */
+	if (akai_read_file(0,tmpbuf,srcfp,0,srcfp->size)<0){
+		PRINTF_OUT("read error\n");
+		free(tmpbuf);
+		return -1;
+	}
+
+	/* write file */
+	if (akai_write_file(0,tmpbuf,&tmpfile,0,tmpfile.size)<0){
+		PRINTF_OUT("write error\n");
+		free(tmpbuf);
+		return -1;
+	}
+
+	free(tmpbuf);
+	return 0;
+}
+
+
+
+int
+copy_vol_allfiles(struct vol_s *srcvp,struct part_s *dstpp,char *dstname,int delflag,int verbose)
+{
+	struct vol_s tmpvol;
+	struct file_s tmpfile;
+	u_int fi;
+
+	if ((srcvp==NULL)||(dstpp==NULL)){
+		return -1;
+	}
+	if (dstpp->type==PART_TYPE_DD){
+		return -1;
+	}
+
+	if (dstname==NULL){ /* no user-supplied name? */
+		dstname=srcvp->name;
+	}
+
+	/* check if destination volume already exists */
+	if (akai_find_vol(dstpp,&tmpvol,dstname)<0){
+		/* does not exist (or error in finding it, don't care) */
+		/* create volume */
+		if (akai_create_vol(dstpp,&tmpvol,
+							srcvp->type,
+							AKAI_CREATE_VOL_NOINDEX,
+							dstname,
+							srcvp->lnum,
+							srcvp->param)<0){
+			PRINTF_ERR("cannot create destination volume\n");
+			return -1;
+		}
+	}else{
+		/* volume already exists */
+		/* copy load number and volume parameters */
+		if (akai_rename_vol(&tmpvol,NULL,
+							srcvp->lnum,
+							srcvp->osver,
+							srcvp->param)<0){
+			PRINTF_ERR("cannot update volume\n");
+			return -1;
+		}
+	}
+
+	/* same volume? Note: same partition and same block should be unique */
+	if ((srcvp->partp==tmpvol.partp)&&(srcvp->dirblk[0]==tmpvol.dirblk[0])){
+		PRINTF_ERR("cannot copy into same volume\n");
+		return -1;
+	}
+
+	/* files in volume directory */
+	for (fi=0;fi<srcvp->fimax;fi++){
+		/* get source file */
+		if (akai_get_file(srcvp,&tmpfile,fi)<0){
+			continue; /* next file */
+		}
+
+		if (verbose>0){
+			if (verbose>1){
+				PRINTF_OUT("%s/",srcvp->name);
+			}
+			PRINTF_OUT("%s\n",tmpfile.name);
+		}
+
+		if (copy_file(&tmpfile,&tmpvol,NULL,AKAI_CREATE_FILE_NOINDEX,NULL,delflag)<0){
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+
+int
+copy_part_allvols(struct part_s *srcpp,struct part_s *dstpp,int delflag,int verbose)
+{
+	u_int vi;
+	struct vol_s tmpvol;
+
+	if ((srcpp==NULL)||(dstpp==NULL)){
+		return -1;
+	}
+	if ((srcpp->type==PART_TYPE_DD)||(dstpp->type==PART_TYPE_DD)){
+		return -1;
+	}
+
+	/* same partition? Note: partition pointer is unique */
+	if (srcpp==dstpp){
+		PRINTF_ERR("cannot copy into same partition\n");
+		return -1;
+	}
+
+	/* volumes in root directory */
+	for (vi=0;(vi<srcpp->volnummax)&&(vi<dstpp->volnummax);vi++){
+		/* get volume */
+		if (akai_get_vol(srcpp,&tmpvol,vi)<0){
+			continue; /* next volume */
+		}
+
+		if (verbose>1){
+			PRINTF_OUT("%s/\n",tmpvol.name);
+		}
+
+		/* copy all files in volume */
+		if (copy_vol_allfiles(&tmpvol,dstpp,NULL,delflag,verbose)<0){
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+
+
+int
+check_curnosamplervol(void)
+{
+
+	if (curdiskp==NULL){ /* no disk? */
+		return 1;
+	}
+	if (curpartp==NULL){ /* no partition? */
+		return 1;
+	}
+#if 1
+	/* XXX actually, curvolp==NULL should suffice */
+	if (curpartp->type==PART_TYPE_DD){ /* DD partition? */
+		return 1;
+	}
+#endif
+	if (curvolp==NULL){ /* no sampler volume? */
+		return 1;
+	}
+	/* now, inside a sampler volume */
+	return 0;
+}
+
+int
+check_curnosamplerpart(void)
+{
+
+	if (curdiskp==NULL){ /* no disk? */
+		return 1;
+	}
+	if (curpartp==NULL){ /* no partition? */
+		return 1;
+	}
+	if (curpartp->type==PART_TYPE_DD){ /* DD partition? */
+		return 1;
+	}
+	if (curvolp!=NULL){ /* sampler volume? */
+		return 1;
+	}
+	/* now, on sampler partition level */
+	return 0;
+}
+
+int
+check_curnoddpart(void)
+{
+
+	if (curdiskp==NULL){ /* no disk? */
+		return 1;
+	}
+	if (curpartp==NULL){ /* no partition? */
+		return 1;
+	}
+	if (curpartp->type!=PART_TYPE_DD){ /* no DD partition? */
+		return 1;
+	}
+	/* now, on DD partition level */
+	return 0;
+}
+
+int
+check_curnopart(void)
+{
+
+	if (curdiskp==NULL){ /* no disk? */
+		return 1;
+	}
+	if (curpartp==NULL){ /* no partition? */
+		return 1;
+	}
+	if (curvolp!=NULL){ /* sampler volume? */
+		return 1;
+	}
+	/* now, on partition level (sampler or DD) */
+	return 0;
+}
+
+
+
+/* EOF */
diff --git a/third_party/akaiutil/akaiutil.h b/third_party/akaiutil/akaiutil.h
new file mode 100755
index 0000000..90ad1dd
--- /dev/null
+++ b/third_party/akaiutil/akaiutil.h
@@ -0,0 +1,674 @@
+#ifndef __AKAIUTIL_H
+#define __AKAIUTIL_H
+/*
+* Copyright (C) 2008,2010,2012,2018,2019,2020,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+
+
+
+/* AKAI S900/S1000/S3000 filesystems */
+
+/* Note: all data types are little endian */
+
+
+
+/* floppy */
+
+/* floppy filesystem blocksize */
+#define AKAI_FL_BLOCKSIZE		0x0400 /* 1KB */
+/* Note: must be == AKAI_FL_SECSIZE (low-level floppy sector size, defined in akaiutil_io.h) */
+#if defined(AKAI_FL_SECSIZE)&&(AKAI_FL_BLOCKSIZE!=AKAI_FL_SECSIZE)
+#error "AKAI_FL_BLOCKSIZE!=AKAI_FL_SECSIZE"
+#endif
+
+#define AKAI_FLL_SIZE			0x0320 /* low-density floppy size in floppy blocks (800KB) */
+#define AKAI_FLH_SIZE			0x0640 /* high-density floppy size in floppy blocks (1.6MB) */
+
+
+
+/* harddisk */
+
+/* harddisk filesystem blocksize */
+#define AKAI_HD_BLOCKSIZE		0x2000 /* 8KB */
+
+/* S900 harddisk */
+#define AKAI_HD9_MAXSIZE		0x1fff /* max. harddisk size in harddisk blocks (approx. 64MB) */
+#define AKAI_HD9_DEFSIZE		0x09c4 /* default harddisk size in harddisk blocks (approx. 19.5MB) */
+#define AKAI_HD9_SH205SIZE		0x0a29 /* "Atari SH205" harddisk size in harddisk blocks (approx. 20.3MB) */
+#define AKAI_HD9_SUPRA20MSIZE	0x09c4 /* "Supra 20M" harddisk size in harddisk blocks (approx. 19.5MB) */
+#define AKAI_HD9_SUPRA30MSIZE	0x0ee4 /* "Supra 30M" harddisk size in harddisk blocks (approx. 29.8MB) */
+#define AKAI_HD9_SUPRA60MSIZE	0x1dc8 /* "Supra 60M" harddisk size in harddisk blocks (approx. 59.6MB) */
+
+/* S1000/S3000 harddisk */
+#define AKAI_HD_MAXSIZE			0xffff /* max. harddisk size in harddisk blocks (approx. 512MB, Note: for 16bit block numbers) */
+
+/* S1000/S3000 harddisk sampler partition */
+#define AKAI_PART_MAXSIZE		0x1e00 /* max. sampler partition size in harddisk blocks (60MB) */
+#define AKAI_PART_NUM			18 /* max. number of sampler partitions per harddisk */
+
+/* S1100/S3000 harddisk DD partition */
+/* Note: max. DD partition size in harddisk blocks is AKAI_HD_MAXSIZE */
+#define AKAI_DDPART_CBLKS		0x20 /* number of blocks per DD partition cluster */
+#define AKAI_DDPART_NUM			18 /* max. number of DD partitions per harddisk */
+
+
+
+/* max. disk size in bytes, Note: fits into 32bit */
+#define AKAI_DISKSIZE_MAX		(AKAI_HD_MAXSIZE*AKAI_HD_BLOCKSIZE)
+
+
+
+/* names */
+
+#define AKAI_NAME_LEN_S900	10 /* for S900 */
+#define AKAI_NAME_LEN		12 /* for S1000/S3000 */
+
+
+
+/* FAT (for floppies and harddisk sampler partitions) */
+
+#define AKAI_FAT_CODE_FREE			0x0000 /* free block */
+#define AKAI_FAT_CODE_BAD			0x2000 /* bad block */
+#define AKAI_FAT_CODE_SYS900FL		0x0000 /* block reserved for system (S900 floppy), warning: same as for free block!!! */
+#define AKAI_FAT_CODE_SYS900HD		0xffff /* block reserved for system (S900 harddisk) */
+#define AKAI_FAT_CODE_SYS			0x4000 /* block reserved for system (S1000/S3000) */
+#define AKAI_FAT_CODE_DIREND900HD	0x8000 /* end of chain for volume directory (S900 harddisk) */
+#define AKAI_FAT_CODE_DIREND1000HD	0x4000 /* end of chain for volume directory (S1000 harddisk), warning: same as for system block!!! */
+#define AKAI_FAT_CODE_DIREND3000	0x8000 /* end of chain for volume directory (S3000) */
+#define AKAI_FAT_CODE_FILEEND900	0x8000 /* end of chain for file (S900) */
+#define AKAI_FAT_CODE_FILEEND		0xc000 /* end of chain for file (S1000/S3000) */
+
+
+
+/* DD FAT (for S1100/S3000 harddisk DD partition) */
+
+#define AKAI_DDFAT_CODE_FREE		0x0000 /* free cluster */
+#define AKAI_DDFAT_CODE_BAD			0x2000 /* bad cluster */
+#define AKAI_DDFAT_CODE_SYS			0x8000 /* cluster reserved for system (header cluster) */
+#define AKAI_DDFAT_CODE_END			0xffff /* end of chain */
+
+
+
+/* OS versions for volumes and files */
+
+#define AKAI_OSVER_S900VOL			0x0000 /* OS version of S900/S950 volume (zero) */
+#define AKAI_OSVER_S1000MAX			0x0428 /* max. OS version of S1000 ("4.40") */
+#define AKAI_OSVER_S1100MAX			0x091e /* max. OS version of S1100 ("9.30") */
+#define AKAI_OSVER_S3000MAX			0x1100 /* max. OS version of S3000 ("17.00") */
+
+
+
+/* file */
+
+#define AKAI_FILE_SIZEMAX	0xffffff /* max. file size in bytes (approx. 16MB, Note: for 24bit size in volume directory entry for file) */
+
+/* entry in volume directory for file */
+struct akai_voldir_entry_s{
+	/* Note: S900 uses first AKAI_NAME_LEN900 chars in name, rest is zero */
+	u_char name[AKAI_NAME_LEN];  /* file name */
+#define AKAI_FILE_TAGNUM	0x04 /* number of tags in volume directory entry for file */
+#define AKAI_FILE_TAGFREE	0x00 /* invalid tag number, means: free tag entry for S3000 */
+#define AKAI_FILE_TAGS1000	0x20 /* invalid tag number, default for S1000 */
+	/* Note: valid tag numbers are 1, ..., AKAI_PARTHEAD_TAGNUM */
+	/* Note: S900 has no tags, all zero */
+	u_char tag[AKAI_FILE_TAGNUM]; /* tags */
+#define AKAI_FTYPE_FREE		0x00 /* invalid file type, means: free entry in volume directory */
+	u_char type; /* file type */
+	u_char size[3];  /* file size in bytes (Note: 24bit) */
+	u_char start[2]; /* start block within partition */
+	u_char osver[2]; /* if S1000/S3000: OS version */
+					 /* if S900 compressed file: number of un-compressed floppy blocks */
+					 /* else: zero */
+}; /* Note: should be 0x0018 Bytes */
+
+
+
+/* volume parameters */
+/* Note: S900 has no volume parameters */
+struct akai_volparam_s{
+	u_char progselmidich1; /* program select MIDI channel-1 */
+	u_char progselomni;    /* MIDI OMNI for program select */
+	u_char progselenab;    /* program select enable */
+	u_char prognr1;        /* selected program number-1 */
+	u_char playinominovrr; /* MIDI OMNI override for play input */
+	u_char sysexch1;       /* MIDI system exclusive channel-1 */
+	u_char dummy1[42];     /* XXX */
+}; /* Note: should be 0x0030 Bytes */
+
+
+
+/* harddisk volumes */
+
+/* harddisk volume directory of files */
+#define AKAI_VOLDIR_ENTRIES_S900HD		128 /* total number of volume directory entries for S900 */
+#define AKAI_VOLDIR_ENTRIES_S1000HD		126 /* total number of volume directory entries for S1000 */
+#define AKAI_VOLDIR_ENTRIES_S3000HD		510 /* total number of volume directory entries for S3000 */
+#define AKAI_VOLDIR_ENTRIES_1BLKHD		341 /* max. number of volume directory entries in 1 harddisk block */
+
+/* S900 harddisk volume */
+struct akai_voldir900hd_s{
+	struct akai_voldir_entry_s file[AKAI_VOLDIR_ENTRIES_S900HD]; /* volume directory entries for files */
+	u_char dummy1[0x1400]; /* XXX */
+}; /* Note: should be 1 harddisk block */
+#define AKAI_VOLDIR900HD_BLKS		1
+
+/* S1000 harddisk volume */
+struct akai_voldir1000hd_s{
+	struct akai_voldir_entry_s file[AKAI_VOLDIR_ENTRIES_S1000HD]; /* volume directory entries for files */
+	struct akai_volparam_s param; /* volume parameters */
+	u_char dummy1[0x1400]; /* XXX */
+}; /* Note: should be 1 harddisk block */
+#define AKAI_VOLDIR1000HD_BLKS		1
+
+/* S3000 harddisk volume */
+struct akai_voldir3000hd_s{
+	struct akai_voldir_entry_s file[AKAI_VOLDIR_ENTRIES_S3000HD]; /* volume directory entries for files */
+	struct akai_volparam_s param; /* volume parameters */
+	u_char dummy1[0x1000]; /* XXX */
+}; /* Note: should be 2 harddisk blocks */
+#define AKAI_VOLDIR3000HD_BLKS		2
+
+
+
+/* floppy volumes */
+
+/* floppy volume directory of files */
+#define AKAI_VOLDIR_ENTRIES_S1000FL		64  /* number of volume directory entries total for S900 and S1000 floppy */
+#define AKAI_VOLDIR_ENTRIES_S3000FL		510 /* number of volume directory entries total for S3000 floppy */
+
+/* floppy volume label */
+/* Note: S900 has no floppy volume label, all zero */
+struct akai_flvol_label_s{
+	u_char name[AKAI_NAME_LEN];   /* volume name */
+	u_char dummy1[2];             /* XXX */
+	u_char osver[2];              /* OS version */
+	struct akai_volparam_s param; /* volume parameters */
+}; /* Note: should be 0x0040 Bytes */
+
+/* low-density floppy header */
+/* Note: S900 and S1000 floppy volume directory is within floppy header */
+struct akai_fllhead_s{
+	struct akai_voldir_entry_s file[AKAI_VOLDIR_ENTRIES_S1000FL]; /* volume directory entries for files */
+#define AKAI_FAT_ENTRIES_FLL	AKAI_FLL_SIZE /* number of FAT entries */
+	u_char fatblk[AKAI_FAT_ENTRIES_FLL][2]; /* FAT entries for floppy blocks: next block or special code */
+	/* Note: S900 has no floppy volume label, all zero */
+	struct akai_flvol_label_s label; /* label */
+	u_char dummy1[0x0380]; /* XXX */
+}; /* Note: should be 4 floppy blocks */
+#define AKAI_FLLHEAD_BLKS	4
+
+/* high-density floppy header */
+/* Note: S900 and S1000 floppy volume directory is within floppy header */
+/* Note: low- and high-density floppy headers are identical */
+/*       up to first AKAI_FAT_ENTRIES_FLL FAT-entries */
+struct akai_flhhead_s{
+	struct akai_voldir_entry_s file[AKAI_VOLDIR_ENTRIES_S1000FL]; /* volume directory entries for files */
+#define AKAI_FAT_ENTRIES_FLH	AKAI_FLH_SIZE /* number of FAT entries */
+	u_char fatblk[AKAI_FAT_ENTRIES_FLH][2]; /* FAT entries for floppy blocks: next block or special code */
+	/* Note: S900 has no floppy volume label, all zero */
+	struct akai_flvol_label_s label; /* label */
+	u_char dummy1[0x0140]; /* XXX */
+}; /* Note: should be 5 floppy blocks */
+#define AKAI_FLHHEAD_BLKS	5
+
+/* S3000 floppy volume directory (behind header) */
+struct akai_voldir3000fl_s{
+	struct akai_voldir_entry_s file[AKAI_VOLDIR_ENTRIES_S3000FL]; /* volume directory entries for files */
+	u_char dummy1[0x0030]; /* Note: volume parameters are in floppy header */
+}; /* Note: should be 12 floppy blocks */
+#define AKAI_VOLDIR3000FL_BLKS		12
+#define AKAI_VOLDIR3000FLL_BSTART	4 /* start block for low-density */
+#define AKAI_VOLDIR3000FLH_BSTART	5 /* start block for high-density */
+/* flag for S3000 floppy: invalid type of first file in floppy header */
+#define AKAI_VOLDIR3000FL_FTYPE		0xff /* invalid file type, used as flag for S3000 floppy volume */
+
+
+
+/* generic volume */
+/* Note: first file starts at byte 0 in first block */
+union akai_voldir_u{
+	struct akai_voldir900hd_s s900hd;
+	struct akai_voldir1000hd_s s1000hd;
+	struct akai_voldir3000hd_s s3000hd;
+	/* Note: S900 and S1000 floppy volume is within floppy header */
+	struct akai_voldir3000fl_s s3000fl;
+};
+
+
+
+/* entry in root directory for volume on S900 harddisk */
+struct akai_hd9rootdir_entry_s{
+	u_char name[AKAI_NAME_LEN_S900]; /* volume name */
+#define AKAI_VOL_START_INACT		0x0000 /* inactive */
+	u_char start[2]; /* start block on harddisk */
+}; /* Note: should be 0x000c Bytes */
+
+
+
+/* S900 harddisk header */
+struct akai_hd9head_s{
+#define AKAI_HD9ROOTDIR_ENTRIES		128 /* number of root directory entries for volumes */
+	struct akai_hd9rootdir_entry_s vol[AKAI_HD9ROOTDIR_ENTRIES]; /* root directory for volumes */
+	u_char size[2]; /* harddisk size in harddisk blocks */
+#define AKAI_HD9FLAG1_SIZEVALID		0xff /* if size[] is valid */
+	u_char flag1; /* XXX */
+	u_char flag2; /* XXX */
+#define AKAI_HD9FAT0_ENTRIES	0x0cfe /* number of copied FAT entries */
+	u_char fatblk0[AKAI_HD9FAT0_ENTRIES][2]; /* copy of first FAT entries */
+#define AKAI_HD9FAT_ENTRIES		AKAI_HD9_MAXSIZE /* max. number of FAT entries */
+	u_char fatblk[AKAI_HD9FAT_ENTRIES][2]; /* FAT entries for harddisk blocks: next block or special code */
+	u_char dummy1[0x6000-AKAI_HD9FAT_ENTRIES*2]; /* XXX */
+}; /* Note: should be 4 harddisk blocks */
+#define AKAI_HD9HEAD_BLKS	4
+
+
+
+/* entry in root directory for volume in S1000/S3000 harddisk sampler partition */
+struct akai_rootdir_entry_s{
+	u_char name[AKAI_NAME_LEN]; /* volume name */
+#define AKAI_VOL_TYPE_INACT		0x00 /* inactive */
+#define AKAI_VOL_TYPE_S1000		0x01 /* S1000 */
+#define AKAI_VOL_TYPE_S3000		0x03 /* S3000 or CD3000 */
+#define AKAI_VOL_TYPE_CD3000	0x07 /* CD3000 CD-ROM (compatible with AKAI_VOL_TYPE_S3000) */
+	u_char type; /* volume type */
+#define AKAI_VOL_LNUM_OFF	0
+#define AKAI_VOL_LNUM_MIN	1
+#define AKAI_VOL_LNUM_MAX	128
+	u_char lnum; /* load number */
+	u_char start[2]; /* start block within partition */
+}; /* Note: should be 0x0010 Bytes */
+
+
+
+/* S1000/S3000 harddisk sampler and DD partition table (only in first sampler partition) */
+struct akai_parttab_s{
+#define AKAI_PARTTAB_MAGICNUM	128 /* number of fields */
+#define AKAI_PARTTAB_MAGICVAL	9999 /* magic base value */
+	u_char magic[AKAI_PARTTAB_MAGICNUM][2]; /* magic fields, indicate S1000/S3000 harddisk partition table, only in first sampler partition */
+	u_char partnum;   /* number of sampler partitions, only in first sampler partition */
+	u_char ddpartnum; /* number of DD partitions */
+	u_char part[AKAI_PART_NUM+1][2];     /* sampler partition table, only in first sampler partition */
+	u_char ddpart[AKAI_DDPART_NUM+1][2]; /* DD partition table, only in first sampler partition */
+	u_char dummy1[0x0100-2-2*(AKAI_PART_NUM+1)-2*(AKAI_DDPART_NUM+1)]; /* XXX */
+}; /* Note: should be 0x0202 Bytes */
+
+
+
+/* S1000/S3000 harddisk sampler partition header */
+struct akai_parthead_s{
+	u_char size[2]; /* partition size in harddisk blocks */
+#define AKAI_PARTHEAD_MAGICNUM	98 /* number of fields */
+#define AKAI_PARTHEAD_MAGICVAL	3333 /* magic base value */
+	u_char magic[AKAI_PARTHEAD_MAGICNUM][2]; /* magic fields, indicate S1000/S3000 harddisk sampler partition */
+	u_char chksum[4]; /* checksum of all above */
+#define AKAI_ROOTDIR_ENTRIES	100 /* number of root directory entries for volumes */
+	struct akai_rootdir_entry_s vol[AKAI_ROOTDIR_ENTRIES]; /* root directory for volumes */
+#define AKAI_FAT_ENTRIES	AKAI_PART_MAXSIZE /* max. number of FAT entries */
+	u_char fatblk[AKAI_FAT_ENTRIES][2]; /* FAT entries for sampler partition blocks: next block or special code */
+	u_char dummy1[0x00f6]; /* XXX */
+	struct akai_parttab_s parttab; /* partition table, only in first sampler partition */
+#define AKAI_PARTHEAD_TAGSMAGIC	"TAGS" /* magic for tags */
+	u_char tagsmagic[4]; /* magic for tags */
+#define AKAI_PARTHEAD_TAGNUM	26 /* number of tags */
+	u_char tag[AKAI_PARTHEAD_TAGNUM][AKAI_NAME_LEN]; /* tag names */
+	u_char dummy2[0x1a00-4-AKAI_PARTHEAD_TAGNUM*AKAI_NAME_LEN]; /* XXX */
+}; /* Note: should be 3 harddisk blocks */
+#define AKAI_PARTHEAD_BLKS	3
+
+
+
+/* S1100/S3000 DD take header (directory entry in DD partition header) */
+/* XXX should be defined in akaiutil_take.h, but must be in akaiutil.h due to dependencies */
+struct akai_ddtake_s{
+	u_char name[AKAI_NAME_LEN]; /* name */
+	u_char cstarts[2];  /* start cluster for sample */
+	u_char cstarte[2];  /* start cluster for envelope */
+	u_char wstart[4];   /* sample start word (16bit) */
+	u_char wend[4];     /* sample end word (16bit) */
+#define AKAI_DDTAKESTAT_FREE		0x00 /* free directory entry */
+#define AKAI_DDTAKESTAT_USED		0x01 /* used directory entry */
+	u_char stat;        /* directory entry status */
+#define AKAI_DDTAKESTYPE_MONO		0x00 /* sample type mono */
+#define AKAI_DDTAKESTYPE_STEREO		0x01 /* sample type stereo */
+	u_char stype;       /* sample type */
+	u_char srate[2];    /* sample rate in Hz */
+	u_char vspeed[2];   /* varispeed (signed) */
+	u_char finerate[2]; /* fine rate (signed) */
+	u_char wstartm[4];  /* edit marker sample start word (16bit) */
+	u_char wendm[4];    /* edit marker sample end word (16bit) */
+	u_char fadein[2];   /* fade in time in ms */
+	u_char fadeout[2];  /* fade out time in ms */
+	u_char stlvl;       /* stereo output level */
+	u_char pan;         /* panning (signed) */
+	u_char stmix;       /* stereo mix (ON=0x01, OFF=0x00) */
+	u_char midich1;     /* MIDI channel-1 */
+	u_char midinote;    /* MIDI note */
+	u_char startm;      /* start mode */
+	u_char deemph;      /* de-emphasis (ON=0x01, OFF=0x00) */
+	u_char dummy1[5];   /* XXX */
+	u_char predel[2];   /* pre-delay time in ms */
+	u_char outlvl;      /* output level */
+	u_char outch;       /* output channel pair */
+	u_char fxbus;       /* FX bus */
+	u_char sendlvl;     /* send level */
+	u_char dummy2[2];   /* XXX */
+}; /* Note: should be 0x0040 Bytes */
+
+
+
+/* S1100/S3000 harddisk DD partition header */
+struct akai_ddparthead_s{
+#define AKAI_DDFAT_ENTRIES	0x07ff /* max. number of DD FAT entries (AKAI_HD_MAXSIZE/AKAI_DDPART_CBLKS) */
+	u_char fatcl[AKAI_DDFAT_ENTRIES][2]; /* FAT entries for DD partition clusters: next cluster or special code */
+	u_char dummy1[0x2000-AKAI_DDFAT_ENTRIES*2]; /* XXX */
+#define AKAI_DDTAKE_MAXNUM	256 /* max. number of DD takes */
+	struct akai_ddtake_s take[AKAI_DDTAKE_MAXNUM]; /* directory of DD takes */
+}; /* Note: should be 3 harddisk blocks (rest of cluster is junk) */
+#define AKAI_DDPARTHEAD_BLKS	3
+
+#define AKAI_DDTAKE_ENVBLKSIZW	128 /* envelope block size in words */
+#define AKAI_DDTAKE_ENVMAXVAL	0x20 /* max. envelope value */
+
+
+
+/* generic header */
+union akai_head_u{
+	struct akai_fllhead_s fll;   /* low-density floppy header */
+	struct akai_flhhead_s flh;   /* high-density floppy header */
+	struct akai_hd9head_s hd9;   /* S900 harddisk header */
+	struct akai_parthead_s hd;   /* S1000/S3000 harddisk sampler partition header */
+	struct akai_ddparthead_s dd; /* S1000/S3000 harddisk DD partition header */
+};
+/* Note: see comment above: */
+/*       may access files and first blocks in FAT via */
+/*       high-density floppy header also for low-density floppy case */
+
+
+
+/* CD-ROM info header in S1000/S3000 sampler partition */
+struct akai_cdinfohead_s{
+	u_char fnum[2]; /* number of files */
+	u_char volesiz[AKAI_ROOTDIR_ENTRIES][2]; /* size of volume directory entries for files in bytes */
+	u_char cdlabel[AKAI_NAME_LEN]; /* CD-ROM label */
+}; /* Note: should be 0x00d6 Bytes */
+/* Note: followed by voldir entries of files */
+#define AKAI_CDINFO_BLK			AKAI_PARTHEAD_BLKS /* start block (following sampler partition header) */
+#define AKAI_CDINFO_MINSIZB		3 /* min. size in harddisk blocks */
+#define AKAI_CDINFO_DEFLABEL	"CDROM" /* XXX default label */
+
+
+
+/* private data structures */
+
+/* disk */
+struct disk_s{
+	u_int index; /* disk index */
+	int fd; /* disk file descriptor */
+#ifdef _VISUALCPP
+	int fldrn; /* floppy drive number (or -1 if none) */
+#endif /* _VISUALCPP */
+	int readonly; /* read-only flag */
+	OFF64_T startoff; /* start offset in bytes */
+	u_int totsize; /* size in bytes */
+#define DISK_TYPE_FLL	1 /* low-density floppy */
+#define DISK_TYPE_FLH	2 /* high-density floppy */
+#define DISK_TYPE_HD9	9 /* S900 harddisk */
+#define DISK_TYPE_HD	3 /* S1000/S3000 harddisk */
+	u_int type; /* disk type */
+	u_int blksize; /* blocksize in bytes */
+	u_int bsize; /* size in blocks */
+};
+
+/* partition */
+struct part_s{
+	struct disk_s *diskp; /* pointer to disk */
+	int valid; /* check passed */
+#define PART_TYPE_FLL	DISK_TYPE_FLL /* low-density floppy */
+#define PART_TYPE_FLH	DISK_TYPE_FLH /* high-density floppy */
+#define PART_TYPE_HD9	DISK_TYPE_HD9 /* S900 harddisk */
+#define PART_TYPE_HD	DISK_TYPE_HD  /* S1000/S3000 harddisk sampler partition */
+#define PART_TYPE_DD	4             /* S1100/S3000 harddisk DD partition (at end of harddisk) */
+	u_int type; /* partition type */
+	u_int index; /* index on disk */
+	u_int blksize; /* blocksize in bytes */
+	u_int bstart; /* start block on disk */
+	u_int bsize; /* size in blocks */
+	u_int csize; /* if DD partition: size in clusters */
+	u_int bsyssize; /* if not DD partition: reserved blocks for system (partition header or floppy header) */
+	u_int bfree; /* free blocks */
+	u_int bbad; /* bad blocks */
+	u_char (*fat)[2]; /* start of FAT */
+	union akai_head_u head; /* whole header */
+	u_int volnummax; /* if not DD partition: max. number of volumes */
+	char letter; /* letter (ASCII) */
+};
+/* Note: fat points into original part_s head => must not use(!) a copy of a part_s !!! */
+
+/* volume */
+struct vol_s{
+	struct part_s *partp; /* pointer to partition */
+	u_int index; /* index in root directory */
+#define AKAI_VOL_TYPE_S900		0xf9 /* fake type for S900, not valid for type in S1000/S3000 root directory */
+	u_int type; /* volume type */
+	u_int lnum; /* load number */
+	u_int osver; /* OS version */
+#define VOL_DIRBLKS	AKAI_VOLDIR3000FL_BLKS /* XXX max. number of volume blocks */
+	u_int dirblk[VOL_DIRBLKS]; /* directory blocks */
+	u_int fimax; /* max. file entries */
+	struct akai_voldir_entry_s *file; /* pointer to start of files */
+	struct akai_volparam_s *param; /* pointer to volume parameters */
+	union akai_voldir_u dir; /* whole volume directory (except for S900 and S1000 floppy) */
+	char name[AKAI_NAME_LEN+1]; /* name (ASCII), +1 for '\0' */
+};
+/* Note: file, param point into original vol_s dir => must not use(!) a copy of a vol_s !!! */
+/*       => use akai_copy_vol() to obtain a self-contained copy of a vol_s */
+/* Note: must be careful with partp if part_s behind it has changed/disappeared !!! */
+/*       this should never be a problem since system-wide unique and static part[] */
+
+/* sampler file */
+struct file_s{
+	struct vol_s *volp; /* pointer to volume */
+	u_int index; /* index in volume directory */
+	u_int bstart; /* start block */
+	u_int size; /* size in bytes */
+	u_int type; /* type */
+	u_int osver; /* OS version */
+	u_char tag[AKAI_FILE_TAGNUM]; /* tags */
+	char name[AKAI_NAME_LEN+4+1]; /* name (ASCII), +4 for ".<type>", +1 for '\0' */
+};
+/* Note: must be careful with volp if vol_s behind it has changed/disappeared !!! */
+/*       this could be a problem with non-unique curvolp/curvol_buf */
+
+
+
+/* disks */
+#ifndef DISK_NUM_MAX
+#define DISK_NUM_MAX	64 /* XXX */
+#endif
+extern struct disk_s disk[DISK_NUM_MAX]; /* disks, Note: one for each disk, system-wide */
+extern u_int disk_num; /* number of disks */
+
+/* partitions */
+#ifndef PART_NUM_MAX
+#define PART_NUM_MAX	512 /* XXX */
+#endif
+extern struct part_s part[PART_NUM_MAX]; /* partitions, Note: one for each partition, system-wide */
+extern u_int part_num; /* number of partitions */
+
+
+
+/* current directory */
+extern struct disk_s *curdiskp; /* current disk pointer into disk[], NULL if system-level */
+								/* Note: unique, fixed mapping to each file */
+extern struct part_s *curpartp; /* current partition pointer into part[], NULL if disk-level */
+								/* Note: unique, fixed mapping to each partition */
+extern struct vol_s *curvolp; /* current volume pointer into curvol_buf, NULL if disk- or partition-level */
+							  /* Note: neither fixed nor unique mapping to each volume!!! */
+extern struct vol_s curvol_buf; /* current volume buffer, Note: only one buffer, might change volume identity!!! */
+
+/* for operations with current directory, Note: one instance only, not recursive!!! */
+extern int savecurfd;
+extern struct part_s *savecurpartp;
+extern struct vol_s *savecurvolp;
+extern struct vol_s savecurvol_buf;
+extern int savecurvolmodflag; /* modifier flag */
+extern char savecurvolname[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+
+/* Note: dirnamebuf[] must be large enough to contain path of max. possible size */
+#define DIRNAMEBUF_LEN	256 /* XXX */
+extern char dirnamebuf[DIRNAMEBUF_LEN+1]; /* +1 for '\0' */
+
+extern u_char curfiltertag[AKAI_FILE_TAGNUM];
+
+
+
+/* Declarations */
+
+#ifndef PSEUDODISK_NUM_MAX
+#define PSEUDODISK_NUM_MAX		8 /* XXX max. number of pseudo-disks per file descriptor */
+#endif
+extern int open_disk(char *name,int readonly,OFF64_T startoff,u_int pseudodisksize,u_int pseudodisknum);
+extern void close_alldisks(void);
+
+#ifndef AKAI_DISKSIZE_GRAN
+#define AKAI_DISKSIZE_GRAN		2048 /* XXX disk size granularity in bytes, compatible with CD-ROM */
+#endif
+extern u_int akai_disksize(int fd,OFF64_T startoff,u_int disksizemax);
+
+extern int akai_io_blks(struct part_s *pp,u_char *buf,u_int bstart,u_int bsize,int cachealloc,int mode);
+
+extern int akai_openreadonly_extfile(char *name);
+extern int akai_check_extwavname(char *wavname);
+
+extern void akai_countfree_part(struct part_s *pp);
+extern int akai_check_fatblk(u_int blk,u_int bsize,u_int bsyssize);
+extern int print_fatchain(struct part_s *pp,u_int blk);
+extern int akai_free_fatchain(struct part_s *pp,u_int bstart,int writeflag);
+extern int akai_allocate_fatchain(struct part_s *pp,u_int bsize,u_int *bstartp,u_int bcont0,u_int endcode);
+
+extern int akai_scanbad(struct part_s *pp,int markflag);
+
+extern int akai_read_file(int outfd,u_char *outbuf,struct file_s *fp,u_int begin,u_int end);
+extern int akai_write_file(int inpfd,u_char *inpbuf,struct file_s *fp,u_int begin,u_int end);
+
+extern int print_ddfatchain(struct part_s *pp,u_int cstart);
+extern u_int akai_count_ddfatchain(struct part_s *pp,u_int cstart);
+extern int akai_free_ddfatchain(struct part_s *pp,u_int cstart,int writeflag);
+extern int akai_allocate_ddfatchain(struct part_s *pp,u_int csize,u_int *cstartp,u_int ccont0);
+
+extern int akai_export_ddfatchain(struct part_s *pp,u_int cstart,u_int bstart,u_int bsize,int outfd,u_char *outbuf);
+extern int akai_import_ddfatchain(struct part_s *pp,u_int cstart,u_int bstart,u_int bsize,int inpfd,u_char *inpbuf);
+
+extern char akai2ascii(u_char c);
+extern char akai2ascii900(u_char c);
+extern void akai2ascii_name(u_char *aname,char *name,int s900flag);
+extern void akai2ascii_filename(u_char *aname,u_char ft,u_int osver,char *name,int s900flag);
+extern u_char ascii2akai(char a);
+extern u_char ascii2akai900(char a);
+extern void ascii2akai_name(char *name,u_char *aname,int s900flag);
+extern u_char ascii2akai_filename(char *name,u_char *aname,u_int *osverp,int s900flag);
+
+extern void akai_vol_info(struct vol_s *vp,u_int ai,int verbose);
+extern void akai_list_vol(struct vol_s *vp,u_char *filtertagp);
+extern int akai_read_voldir(struct vol_s *vp);
+extern int akai_write_voldir(struct vol_s *vp,u_int fi);
+extern void akai_copy_structvol(struct vol_s *srcvp,struct vol_s *dstvp);
+extern int akai_get_vol(struct part_s *pp,struct vol_s *vp,u_int vi);
+extern int akai_find_vol(struct part_s *pp,struct vol_s *vp,char *name);
+extern int akai_rename_vol(struct vol_s *vp,char *name,u_int lnum,u_int osver,struct akai_volparam_s *parp);
+#define AKAI_CREATE_VOL_NOINDEX	((u_int)-1) /* no user-supplied index */
+extern int akai_create_vol(struct part_s *pp,struct vol_s *vp,u_int type,u_int index,char *name,u_int lnum,struct akai_volparam_s *parp);
+extern int akai_wipe_vol(struct vol_s *vp,int delflag);
+
+extern void akai_list_volparam(struct akai_volparam_s *parp,int listflag);
+extern void akai_init_volparam(struct akai_volparam_s *parp,int s3000flag);
+
+extern void akai_print_lnum(u_int lnum);
+extern u_int akai_get_lnum(char *name);
+
+extern int copy_tags(struct part_s *srcpp,struct part_s *dstpp);
+extern void akai_list_tags(struct part_s *pp);
+extern int akai_rename_tag(struct part_s *pp,char *name,u_int ti,int wipeflag);
+
+extern void akai_print_cdinfo(struct part_s *pp,int verbose);
+extern int akai_set_cdinfo(struct part_s *pp,char *cdlabel);
+
+extern void akai_part_info(struct part_s *pp,int verbose);
+extern void akai_list_part(struct part_s *pp,int recflag,u_char *filtertagp);
+extern struct part_s *akai_find_part(struct disk_s *dp,char *name);
+extern void print_fat(struct part_s *pp);
+
+extern void akai_disk_info(struct disk_s *dp,int verbose);
+extern void akai_list_disk(struct disk_s *dp,int recflag,u_char *filtertagp);
+extern void akai_list_alldisks(int recflag,u_char *filtertagp);
+
+extern void akai_sort_filetags(u_char *tagp);
+extern int akai_set_filetag(u_char *tagp,u_int ti);
+extern int akai_clear_filetag(u_char *tagp,u_int ti);
+extern int akai_match_filetags(u_char *filtertagp,u_char *testtagp);
+extern int akai_get_file(struct vol_s *vp,struct file_s *fp,u_int fi);
+extern int akai_find_file(struct vol_s *vp,struct file_s *fp,char *name);
+extern int akai_rename_file(struct file_s *fp,char *name,struct vol_s *vp,u_int dstindex,u_char *tagp,u_int osver);
+#define AKAI_CREATE_FILE_NOINDEX	((u_int)-1) /* no user-supplied index */
+extern int akai_create_file(struct vol_s *vp,struct file_s *fp,u_int size,u_int index,char *name,u_int osver,u_char *tagp);
+extern void akai_fvol1000_initfile(struct akai_voldir_entry_s *ep,u_int osver,u_int tag);
+extern int akai_delete_file(struct file_s *fp);
+
+extern int akai_rename_ddtake(struct part_s *pp,u_int ti,char *name);
+extern int akai_delete_ddtake(struct part_s *pp,u_int ti);
+
+extern void akai_fix_partheadmagic(struct part_s *pp);
+extern int akai_check_partheadmagic(struct part_s *pp);
+extern void akai_fix_parttabmagic(struct akai_parttab_s *ptp);
+extern int akai_check_parttabmagic(struct akai_parttab_s *ptp);
+
+extern int akai_scan_floppy(struct disk_s *dp);
+extern int akai_scan_harddisk9(struct disk_s *dp);
+extern int akai_scan_ddpart(struct disk_s *dp,struct akai_parttab_s *ptp,u_int bstart,u_int pi);
+extern int akai_scan_disk(struct disk_s *dp,int floppyenable);
+
+extern int akai_wipe_part(struct part_s *pp,int wipeflag,struct part_s *plistp,u_int pimax,int cdromflag);
+extern int akai_wipe_harddisk(struct disk_s *dp,u_int bsize,u_int totb,int s3000flag,int cdromflag);
+extern int akai_wipe_harddisk9(struct disk_s *dp,u_int totb);
+extern int akai_wipe_floppy(struct disk_s *dp,int lodensflag,int s3000flag,int s900flag);
+
+extern int change_curdir(char *name,u_int vi,char *lastname,int checklast);
+extern int change_curdir_home(void);
+extern void save_curdir(int modflag);
+extern void restore_curdir(void);
+extern void curdir_info(int verbose,char *pathbuf);
+extern void list_curdir(int recflag);
+extern void list_curfiltertags(void);
+
+extern int copy_file(struct file_s *srcfp,struct vol_s *dstvp,struct file_s *dstfp,u_int dstindex,char *dstname,int delflag);
+extern int copy_vol_allfiles(struct vol_s *srcvp,struct part_s *dstpp,char *dstname,int delflag,int verbose);
+extern int copy_part_allvols(struct part_s *srcpp,struct part_s *dstpp,int delflag,int verbose);
+
+extern int check_curnosamplervol(void);
+extern int check_curnosamplerpart(void);
+extern int check_curnoddpart(void);
+extern int check_curnopart(void);
+
+
+
+#endif /* !__AKAIUTIL_H */
diff --git a/third_party/akaiutil/akaiutil.sln b/third_party/akaiutil/akaiutil.sln
new file mode 100755
index 0000000..538c8f7
--- /dev/null
+++ b/third_party/akaiutil/akaiutil.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "akaiutil", "akaiutil.vcproj", "{3F010352-C096-4963-887A-7C23C83616DF}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{3F010352-C096-4963-887A-7C23C83616DF}.Debug|Win32.ActiveCfg = Debug|Win32
+		{3F010352-C096-4963-887A-7C23C83616DF}.Debug|Win32.Build.0 = Debug|Win32
+		{3F010352-C096-4963-887A-7C23C83616DF}.Release|Win32.ActiveCfg = Release|Win32
+		{3F010352-C096-4963-887A-7C23C83616DF}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/third_party/akaiutil/akaiutil.vcproj b/third_party/akaiutil/akaiutil.vcproj
new file mode 100755
index 0000000..1957aa1
--- /dev/null
+++ b/third_party/akaiutil/akaiutil.vcproj
@@ -0,0 +1,259 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="akaiutil"
+	ProjectGUID="{3F010352-C096-4963-887A-7C23C83616DF}"
+	RootNamespace="akaiutil"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="WIN32;_VISUALCPP;_DEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE;DEBUG"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Winmm.lib"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+			IntermediateDirectory="$(ConfigurationName)"
+			ConfigurationType="1"
+			CharacterSet="1"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				PreprocessorDefinitions="WIN32;_VISUALCPP;NDEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE"
+				RuntimeLibrary="2"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				AdditionalDependencies="Winmm.lib"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Quelldateien"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\akaiutil.c"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_file.c"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_io.c"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_main.c"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_take.c"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_tar.c"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_wav.c"
+				>
+			</File>
+			<File
+				RelativePath=".\commonlib.c"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Headerdateien"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath=".\akaiutil.h"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_file.h"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_io.h"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_take.h"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_tar.h"
+				>
+			</File>
+			<File
+				RelativePath=".\akaiutil_wav.h"
+				>
+			</File>
+			<File
+				RelativePath=".\commoninclude.h"
+				>
+			</File>
+			<File
+				RelativePath=".\fdrawcmd.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Ressourcendateien"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/third_party/akaiutil/akaiutil_file.c b/third_party/akaiutil/akaiutil_file.c
new file mode 100755
index 0000000..9595702
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_file.c
@@ -0,0 +1,2940 @@
+/*
+* Copyright (C) 2010,2012,2018,2019,2020,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+#include "akaiutil.h"
+#include "akaiutil_file.h"
+#include "akaiutil_wav.h"
+
+
+
+/* AKAI file info */
+int
+akai_file_info(struct file_s *fp,int verbose)
+{
+	static u_char hdrbuf[AKAI_FL_BLOCKSIZE]; /* XXX enough */
+	u_int hdrsize;
+	struct akai_genfilehdr_s *hdrp;
+	static char nbuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	int s900flag;
+	int sampleflag;
+	int programflag;
+	int cuelistflag;
+	int takelistflag;
+	int drum1000flag;
+	u_int i;
+
+	if ((fp==NULL)
+		||(fp->volp==NULL)
+		||(fp->index>=fp->volp->fimax)){
+		return -1;
+	}
+
+	if (verbose){
+		PRINTF_OUT("%s\n",fp->name);
+		PRINTF_OUT("fnr:     %u\n",fp->index+1);
+		PRINTF_OUT("start:   block 0x%04x\n",fp->bstart);
+		PRINTF_OUT("size:    %u bytes\n",fp->size);
+		/* file type */
+		PRINTF_OUT("type:    ");
+		hdrsize=sizeof(struct akai_genfilehdr_s); /* default */
+		s900flag=0; /* default */
+		sampleflag=0; /* default */
+		programflag=0; /* default */
+		cuelistflag=0; /* default */
+		takelistflag=0; /* default */
+		drum1000flag=0; /* default */
+		switch (fp->type){
+		case AKAI_SAMPLE900_FTYPE: /* S900 sample file */
+			PRINTF_OUT("S900 sample\n");
+			hdrsize=sizeof(struct akai_sample900_s);
+			s900flag=1;
+			sampleflag=1;
+			break;
+		case AKAI_SAMPLE1000_FTYPE: /* S1000 sample file */
+			PRINTF_OUT("S1000 sample\n");
+			hdrsize=sizeof(struct akai_sample1000_s);
+			sampleflag=1;
+			break;
+		case AKAI_SAMPLE3000_FTYPE: /* S3000 sample file */
+			PRINTF_OUT("S3000 sample\n");
+			hdrsize=sizeof(struct akai_sample3000_s);
+			sampleflag=1;
+			break;
+		case AKAI_CDSAMPLE3000_FTYPE: /* CD3000 CD-ROM sample parameters file */
+			PRINTF_OUT("CD3000 CD-ROM sample parameters\n");
+			/* Note: contains S3000 sample header */
+			hdrsize=sizeof(struct akai_sample3000_s);
+			sampleflag=1;
+			break;
+		case AKAI_PROGRAM900_FTYPE: /* S900 program file */
+			PRINTF_OUT("S900 program\n");
+			s900flag=1;
+			programflag=1;
+			break;
+		case AKAI_PROGRAM1000_FTYPE: /* S1000 program file */
+			PRINTF_OUT("S1000 program\n");
+			programflag=1;
+			break;
+		case AKAI_PROGRAM3000_FTYPE: /* S3000 program file */
+			PRINTF_OUT("S3000 program\n");
+			programflag=1;
+			break;
+		case AKAI_DRUM900_FTYPE: /* S900/S950 drum settings file */
+			PRINTF_OUT("S900/S950 drum settings\n");
+			/*s900flag=1;*/
+			/* S900/S950 drum settings info */
+			return akai_drum900_info(fp);
+		case AKAI_DRUM1000_FTYPE: /* S1000 or S3000 drum settings file */
+			PRINTF_OUT("S1000/S3000 drum settings\n");
+			drum1000flag=1;
+			break;
+		case AKAI_FXFILE_FTYPE: /* S1100 or S3000 effects file */
+			PRINTF_OUT("S1100/S3000 effects\n");
+			break;
+		case AKAI_QLFILE_FTYPE: /* S1100 or S3000 cue-list file */
+			PRINTF_OUT("S1100/S3000 cue-list\n");
+			cuelistflag=1;
+			break;
+		case AKAI_TLFILE_FTYPE: /* S1100 or S3000 take-list file */
+			PRINTF_OUT("S1100/S3000 take-list\n");
+			takelistflag=1;
+			break;
+		case AKAI_MULTI3000_FTYPE: /* S3000 multi file */
+			PRINTF_OUT("S3000 multi\n");
+			break; /* use generic file header */
+		case AKAI_FIXUP900_FTYPE: /* S900 fixup file */
+			PRINTF_OUT("S900 fixup\n");
+			/*s900flag=1;*/
+			return 0; /* done */
+		case AKAI_MEMIMG900_FTYPE: /* S900 memory image file */
+			PRINTF_OUT("S900 memory image\n");
+			/*s900flag=1;*/
+			return 0; /* done */
+		case AKAI_SYS1000_FTYPE: /* S1000 operating system file */
+			PRINTF_OUT("S1000 operating system\n");
+			return 0; /* done */
+		case AKAI_SYS3000_FTYPE: /* S3000 operating system file */
+			PRINTF_OUT("S3000 operating system\n");
+			return 0; /* done */
+		case AKAI_OVS900_FTYPE: /* S900 overall settings file */
+			PRINTF_OUT("S900 overall settings\n");
+			/*s900flag=1;*/
+			/* S900 overall settings info */
+			return akai_ovs900_info(fp);
+		case AKAI_CDSETUP3000_FTYPE:
+			/* CD3000 CD-ROM setup file */
+			/* Note: generic file header does not apply for this file type! */
+			PRINTF_OUT("CD3000 CD-ROM setup\n");
+			return akai_cdsetup3000_info(fp);
+		default:
+			/* unknown or unsupported */
+			PRINTF_OUT("\?\?\?\n");
+			return 1; /* no error */
+		}
+
+		/* read header */
+		if (akai_read_file(0,hdrbuf,fp,0,hdrsize)<0){
+			PRINTF_ERR("cannot read header\n");
+			return -1;
+		}
+
+		/* name */
+		if (s900flag){ /* S900 type? */
+			/* Note: name in S900 sample/program file header starts at byte 0 */
+			akai2ascii_name(hdrbuf,nbuf,1); /* 1: S900 */
+		}else{
+			/* generic file header */
+			hdrp=(struct akai_genfilehdr_s *)hdrbuf;
+			akai2ascii_name(hdrp->name,nbuf,0); /* 0: not S900 */
+		}
+		PRINTF_OUT("ramname: \"%s\"\n",nbuf);
+		if (sampleflag){
+			/* sample info */
+			akai_sample_info(fp,hdrbuf);
+		}else if (programflag){
+			/* program info */
+			return akai_program_info(fp);
+		}else if (cuelistflag){
+			/* cue-list info */
+			return akai_cuelist_info(fp);
+		}else if (takelistflag){
+			/* take-list info */
+			return akai_takelist_info(fp);
+		}else if (drum1000flag){
+			/* S1000/S3000 drum settings info */
+			return akai_drum1000_info(fp);
+		}
+	}else{
+		PRINTF_OUT("%3u  %-16s %9u    0x%04x  ",fp->index+1,fp->name,fp->size,fp->bstart);
+		if (fp->volp->type==AKAI_VOL_TYPE_S900){
+			/* S900 volume */
+			if (fp->osver!=0){ /* compressed file? */
+				/* number of un-compressed floppy blocks */
+				PRINTF_OUT("  %5u",fp->osver);
+			}
+		}else{
+			/* S1000/S3000 volume */
+			/* OS version */
+			if (((0xff&(fp->osver>>8))<100)&&((0xff&fp->osver)<100)){
+				PRINTF_OUT("%2u.%02u  ",0xff&(fp->osver>>8),0xff&fp->osver);
+			}else{
+				PRINTF_OUT("%5u  ",fp->osver);
+			}
+			/* tags */
+			for (i=0;i<AKAI_FILE_TAGNUM;i++){
+				if ((fp->tag[i]>=1)&&(fp->tag[i]<=AKAI_PARTHEAD_TAGNUM)){
+					PRINTF_OUT("%02u ",fp->tag[i]);
+				}else if ((fp->tag[i]==AKAI_FILE_TAGFREE)||(fp->tag[i]==AKAI_FILE_TAGS1000)){
+					PRINTF_OUT("   ");
+				}else{
+					PRINTF_OUT("?  ");
+				}
+			}
+		}
+		PRINTF_OUT("\n");
+	}
+
+	return 0;
+}
+
+void
+akai_sample_info(struct file_s *fp,u_char *hdrp)
+{
+	struct akai_sample3000_s *s3000hdrp;
+	struct akai_sample900_s *s900hdrp;
+	u_int samplecount;
+	u_int samplerate;
+	u_int i,j,k;
+
+	if ((fp==NULL)||(hdrp==NULL)){
+		return;
+	}
+
+	if (fp->type==AKAI_SAMPLE900_FTYPE){
+		/* S900 sample header */
+		s900hdrp=(struct akai_sample900_s *)hdrp;
+		/* number of samples */
+		/* XXX should be an even number */
+		samplecount=(s900hdrp->slen[3]<<24)
+			+(s900hdrp->slen[2]<<16)
+			+(s900hdrp->slen[1]<<8)
+			+s900hdrp->slen[0];
+		PRINTF_OUT("scount:  0x%08x (%9u)\n",samplecount,samplecount);
+		samplerate=(s900hdrp->srate[1]<<8)+s900hdrp->srate[0];
+		PRINTF_OUT("srate:   %uHz\n",samplerate);
+		if (samplerate>0){
+			PRINTF_OUT("sdur:    %.3lfms\n",1000.0*((double)samplecount)/((double)samplerate));
+		}
+		PRINTF_OUT("npitch:  %.2lf\n",((double)((s900hdrp->npitch[1]<<8)+s900hdrp->npitch[0]))/16.0);
+		PRINTF_OUT("loud:    %+i\n",(((int)(char)s900hdrp->loud[1])<<8)+((int)(u_char)s900hdrp->loud[0]));
+		PRINTF_OUT("dmadesa: 0x%02x%02x\n",
+			s900hdrp->dmadesa[1],
+			s900hdrp->dmadesa[0]);
+		PRINTF_OUT("locat:   0x%02x%02x%02x%02x\n",
+			s900hdrp->locat[3],
+			s900hdrp->locat[2],
+			s900hdrp->locat[1],
+			s900hdrp->locat[0]);
+		PRINTF_OUT("start:   0x%02x%02x%02x%02x\n",
+			s900hdrp->start[3],
+			s900hdrp->start[2],
+			s900hdrp->start[1],
+			s900hdrp->start[0]);
+		PRINTF_OUT("end:     0x%02x%02x%02x%02x\n",
+			s900hdrp->end[3],
+			s900hdrp->end[2],
+			s900hdrp->end[1],
+			s900hdrp->end[0]);
+		PRINTF_OUT("llen:    0x%02x%02x%02x%02x\n",
+			s900hdrp->llen[3],
+			s900hdrp->llen[2],
+			s900hdrp->llen[1],
+			s900hdrp->llen[0]);
+		PRINTF_OUT("pmode:   ");
+		switch (s900hdrp->pmode){
+		case SAMPLE900_PMODE_ONESHOT:
+			PRINTF_OUT("ONESHOT\n");
+			break;
+		case SAMPLE900_PMODE_LOOP:
+			PRINTF_OUT("LOOP\n");
+			break;
+		case SAMPLE900_PMODE_ALTLOOP:
+			PRINTF_OUT("ALTLOOP\n");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?\n");
+			break;
+		}
+		PRINTF_OUT("dir:     ");
+		switch (s900hdrp->dir){
+		case SAMPLE900_DIR_NORM:
+			PRINTF_OUT("NORM\n");
+			break;
+		case SAMPLE900_DIR_REV:
+			PRINTF_OUT("REV\n");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?\n");
+			break;
+		}
+		PRINTF_OUT("type:    ");
+		switch (s900hdrp->type){
+		case SAMPLE900_TYPE_NORM:
+			PRINTF_OUT("NORM\n");
+			break;
+		case SAMPLE900_TYPE_VELXF:
+			PRINTF_OUT("VELXF\n");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?\n");
+			break;
+		}
+		PRINTF_OUT("compr:   %s\n",
+			(fp->osver!=0)?"ON":"OFF"); /* S900 compressed/non-compressed sample format */
+	}else if ((fp->type==AKAI_SAMPLE1000_FTYPE)
+			  ||(fp->type==AKAI_SAMPLE3000_FTYPE)
+			  ||(fp->type==AKAI_CDSAMPLE3000_FTYPE)){
+		/* S1000/S3000 sample header */
+		s3000hdrp=(struct akai_sample3000_s *)hdrp;
+		/* Note: S1000 header is contained within S3000 header */
+		/* number of samples */
+		samplecount=(s3000hdrp->s1000.slen[3]<<24)
+			+(s3000hdrp->s1000.slen[2]<<16)
+			+(s3000hdrp->s1000.slen[1]<<8)
+			+s3000hdrp->s1000.slen[0];
+		PRINTF_OUT("scount:  0x%08x (%9u)\n",samplecount,samplecount);
+		samplerate=(s3000hdrp->s1000.srate[1]<<8)+s3000hdrp->s1000.srate[0];
+		PRINTF_OUT("srate:   %uHz\n",samplerate);
+		if (samplerate>0){
+			PRINTF_OUT("sdur:    %.3lfms\n",1000.0*((double)samplecount)/((double)samplerate));
+		}
+		PRINTF_OUT("bandw:   ");
+		switch (s3000hdrp->s1000.bandw){
+		case SAMPLE1000_BANDW_10KHZ:
+			PRINTF_OUT("10kHz\n");
+			break;
+		case SAMPLE1000_BANDW_20KHZ:
+			PRINTF_OUT("20kHz\n");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?\n");
+			break;
+		}
+		PRINTF_OUT("rkey:    %u\n",s3000hdrp->s1000.rkey);
+		PRINTF_OUT("ctune:   %+i\n",(int)(char)s3000hdrp->s1000.ctune);
+		PRINTF_OUT("stune:   %+i\n",(int)(char)s3000hdrp->s1000.stune);
+		PRINTF_OUT("hltoff:  %+i\n",(int)(char)s3000hdrp->s1000.hltoff);
+		k=(s3000hdrp->s1000.stpaira[1]<<8)+s3000hdrp->s1000.stpaira[0];
+		if (k!=AKAI_SAMPLE1000_STPAIRA_NONE){
+			if (fp->type==AKAI_SAMPLE3000_FTYPE){
+				k*=SAMPLE3000_STPAIRA_MULT;
+				PRINTF_OUT("stpaira: 0x%05x\n",k);
+			}else{
+				PRINTF_OUT("stpaira: 0x%04x\n",k);
+			}
+		}
+		PRINTF_OUT("locat:   0x%02x%02x%02x%02x\n",
+			s3000hdrp->s1000.locat[3],
+			s3000hdrp->s1000.locat[2],
+			s3000hdrp->s1000.locat[1],
+			s3000hdrp->s1000.locat[0]);
+		PRINTF_OUT("start:   0x%02x%02x%02x%02x\n",
+			s3000hdrp->s1000.start[3],
+			s3000hdrp->s1000.start[2],
+			s3000hdrp->s1000.start[1],
+			s3000hdrp->s1000.start[0]);
+		PRINTF_OUT("end:     0x%02x%02x%02x%02x\n",
+			s3000hdrp->s1000.end[3],
+			s3000hdrp->s1000.end[2],
+			s3000hdrp->s1000.end[1],
+			s3000hdrp->s1000.end[0]);
+		PRINTF_OUT("pmode:   ");
+		switch (s3000hdrp->s1000.pmode){
+		case SAMPLE1000_PMODE_LOOP:
+			PRINTF_OUT("LOOP\n");
+			break;
+		case SAMPLE1000_PMODE_LOOPNOTREL:
+			PRINTF_OUT("LOOPNOTREL\n");
+			break;
+		case SAMPLE1000_PMODE_NOLOOP:
+			PRINTF_OUT("NOLOOP\n");
+			break;
+		case SAMPLE1000_PMODE_TOEND:
+			PRINTF_OUT("TOEND\n");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?\n");
+			break;
+		}
+		PRINTF_OUT("lnum:    %u\n",s3000hdrp->s1000.lnum);
+		PRINTF_OUT("lfirst:  %u\n",s3000hdrp->s1000.lfirst+1);
+		for (i=0;i<AKAI_SAMPLE1000_LOOPNUM;i++){
+			k=(s3000hdrp->s1000.loop[i].time[1]<<8)+s3000hdrp->s1000.loop[i].time[0];
+			if (k==SAMPLE1000LOOP_TIME_NOLOOP){
+				continue; /* next loop */
+			}
+			j=(s3000hdrp->s1000.loop[i].at[3]<<24)
+				+(s3000hdrp->s1000.loop[i].at[2]<<16)
+				+(s3000hdrp->s1000.loop[i].at[1]<<8)
+				+s3000hdrp->s1000.loop[i].at[0];
+			if (j>=samplecount){ /* invalid? */
+				continue; /* next loop */
+			}
+			PRINTF_OUT("loop %u:\n",i+1);
+			PRINTF_OUT("  loopat:  0x%08x\n",j);
+			PRINTF_OUT("  length:  0x%02x%02x%02x%02x.0x%02x%02x\n",
+				s3000hdrp->s1000.loop[i].len[3],
+				s3000hdrp->s1000.loop[i].len[2],
+				s3000hdrp->s1000.loop[i].len[1],
+				s3000hdrp->s1000.loop[i].len[0],
+				s3000hdrp->s1000.loop[i].flen[1],
+				s3000hdrp->s1000.loop[i].flen[0]);
+			if (k==SAMPLE1000LOOP_TIME_HOLD){
+				PRINTF_OUT("  ltime:   HOLD\n");
+			}else{
+				PRINTF_OUT("  ltime:   %ums\n",k);
+			}
+		}
+	}
+}
+
+int
+akai_program_info(struct file_s *fp)
+{
+	static char nbuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	struct akai_program900_s *s900hdrp;
+	struct akai_program900kg_s *s900kgp;
+	struct akai_program3000_s *s3000hdrp;
+	struct akai_program3000kg_s *s3000kgp;
+	u_char *buf;
+	u_int hdrsiz;
+	u_int kgsiz;
+	u_int kgnum;
+	u_int i,j,k;
+
+	if ((fp==NULL)||(fp->volp==NULL)||(fp->index>=fp->volp->fimax)){
+		return -1;
+	}
+
+	if (fp->type==AKAI_PROGRAM900_FTYPE){
+		hdrsiz=sizeof(struct akai_program900_s);
+		kgsiz=sizeof(struct akai_program900kg_s);
+	}else if (fp->type==AKAI_PROGRAM1000_FTYPE){
+		hdrsiz=sizeof(struct akai_program1000_s);
+		kgsiz=sizeof(struct akai_program1000kg_s);
+	}else if (fp->type==AKAI_PROGRAM3000_FTYPE){
+		hdrsiz=sizeof(struct akai_program3000_s);
+		kgsiz=sizeof(struct akai_program3000kg_s);
+	}else{
+		return -1;
+	}
+
+	/* allocate buffer */
+	if (fp->size<hdrsiz){
+		PRINTF_ERR("invalid file size\n");
+		return -1;
+	}
+	if ((buf=(u_char *)malloc(fp->size))==NULL){
+		PRINTF_ERR("cannot allocate memory\n");
+		return -1;
+	}
+
+	/* read file */
+	if (akai_read_file(0,buf,fp,0,fp->size)<0){
+		PRINTF_ERR("cannot read file\n");
+		free(buf);
+		return -1;
+	}
+
+	if (fp->type==AKAI_PROGRAM900_FTYPE){
+		/* S900 program header */
+		s900hdrp=(struct akai_program900_s *)buf;
+		PRINTF_OUT("kgxf:    %s\n",(s900hdrp->kgxf!=0x00)?"ON":"OFF");
+		kgnum=s900hdrp->kgnum;
+		PRINTF_OUT("kgnum:   %u\n",kgnum);
+		if (fp->size<hdrsiz+kgnum*kgsiz){
+			PRINTF_ERR("invalid file size\n");
+			free(buf);
+			return -1;
+		}
+		k=(s900hdrp->kg1a[1]<<8)+s900hdrp->kg1a[0];
+		if (k!=PROGRAM900_KGA_NONE){
+			PRINTF_OUT("kg1a:    0x%04x\n",k);
+		}
+		for (i=0;i<kgnum;i++){
+			PRINTF_OUT("keygroup %u:\n",i+1);
+			s900kgp=(struct akai_program900kg_s *)(buf+hdrsiz+i*kgsiz);
+			PRINTF_OUT("  midichoff: %u\n",s900kgp->midichoff);
+			PRINTF_OUT("  key lo-hi: %u-%u\n",s900kgp->keylo,s900kgp->keyhi);
+			PRINTF_OUT("  outch:     ");
+			switch (s900kgp->outch1){
+			case PROGRAM900KG_OUTCH1_LEFT:
+				PRINTF_OUT("LEFT\n");
+				break;
+			case PROGRAM900KG_OUTCH1_RIGHT:
+				PRINTF_OUT("RIGHT\n");
+				break;
+			case PROGRAM900KG_OUTCH1_ANY:
+				PRINTF_OUT("ANY\n");
+				break;
+			default:
+				PRINTF_OUT("%u\n",s900kgp->outch1+1);
+				break;
+			}
+			PRINTF_OUT("  pitch:     %s\n",((PROGRAM900KG_FLAGS_PCONST&s900kgp->flags)!=0x00)?"CONST":"TRACK");
+			PRINTF_OUT("  oneshot:   %s\n",((PROGRAM900KG_FLAGS_ONESHOT&s900kgp->flags)!=0x00)?"ON":"OFF");
+			PRINTF_OUT("  velxf:     %s\n",((PROGRAM900KG_FLAGS_VELXF&s900kgp->flags)!=0x00)?"ON":"OFF");
+			PRINTF_OUT("  velxfv50:  %u\n",s900kgp->velxfv50);
+			PRINTF_OUT("  velswth:   %u",s900kgp->velswth);
+			if (s900kgp->velswth<=PROGRAM900KG_VELSWTH_NOSOFT){
+				PRINTF_OUT(" (no soft sample)\n");
+			}else if (s900kgp->velswth>=PROGRAM900KG_VELSWTH_NOLOUD){
+				PRINTF_OUT(" (no loud sample)\n");
+			}else{
+				PRINTF_OUT("\n");
+			}
+			PRINTF_OUT("  sample 1 (soft):\n");
+			PRINTF_OUT("    tune:    %+.2lf\n",((double)((((int)(char)s900kgp->tune1[1])<<8)+((int)(u_char)s900kgp->tune1[0])))/16.0);
+			PRINTF_OUT("    filter:  %u\n",s900kgp->filter1);
+			PRINTF_OUT("    loud:    %+i\n",(int)(char)s900kgp->loud1);
+			akai2ascii_name(s900kgp->sname1,nbuf,1); /* 1: S900 */
+			PRINTF_OUT("    sname:   \"%s\"\n",nbuf);
+			k=(s900kgp->shdra1[1]<<8)+s900kgp->shdra1[0];
+			if (k!=PROGRAM900KG_SHDRA_NONE){
+				PRINTF_OUT("    shdra:   0x%04x\n",k);
+			}
+			PRINTF_OUT("  sample 2 (loud):\n");
+			PRINTF_OUT("    tune:    %+.2lf\n",((double)((((int)(char)s900kgp->tune2[1])<<8)+((int)(u_char)s900kgp->tune2[0])))/16.0);
+			PRINTF_OUT("    filter:  %u\n",s900kgp->filter2);
+			PRINTF_OUT("    loud:    %+i\n",(int)(char)s900kgp->loud2);
+			akai2ascii_name(s900kgp->sname2,nbuf,1); /* 1: S900 */
+			PRINTF_OUT("    sname:   \"%s\"\n",nbuf);
+			k=(s900kgp->shdra2[1]<<8)+s900kgp->shdra2[0];
+			if (k!=PROGRAM900KG_SHDRA_NONE){
+				PRINTF_OUT("    shdra:   0x%04x\n",k);
+			}
+			k=(s900kgp->kgnexta[1]<<8)+s900kgp->kgnexta[0];
+			if (k!=PROGRAM900_KGA_NONE){
+				PRINTF_OUT("  kgnexta:   0x%04x\n",k);
+			}
+		}
+	}else{
+		/* S1000/S3000 program header */
+		s3000hdrp=(struct akai_program3000_s *)buf;
+		/* Note: S1000 header is contained within S3000 header */
+		PRINTF_OUT("midich:    ");
+		if (s3000hdrp->s1000.midich1==PROGRAM1000_MIDICH1_OMNI){
+			PRINTF_OUT("OMNI\n");
+		}else{
+			PRINTF_OUT("%u\n",s3000hdrp->s1000.midich1+1);
+		}
+		PRINTF_OUT("key lo-hi: %u-%u\n",s3000hdrp->s1000.keylo,s3000hdrp->s1000.keyhi);
+		PRINTF_OUT("oct:       %+i\n",(int)(char)s3000hdrp->s1000.oct);
+		PRINTF_OUT("auxch:     ");
+		if (s3000hdrp->s1000.auxch1==PROGRAM1000_AUXCH1_OFF){
+			PRINTF_OUT("OFF\n");
+		}else{
+			PRINTF_OUT("%u\n",s3000hdrp->s1000.auxch1+1);
+		}
+		PRINTF_OUT("kgxf:      %s\n",(s3000hdrp->s1000.kgxf!=0x00)?"ON":"OFF");
+		kgnum=s3000hdrp->s1000.kgnum;
+		PRINTF_OUT("kgnum:     %u\n",kgnum);
+		if (fp->size<hdrsiz+kgnum*kgsiz){
+			PRINTF_ERR("invalid file size\n");
+			free(buf);
+			return -1;
+		}
+		k=(s3000hdrp->s1000.kg1a[1]<<8)+s3000hdrp->s1000.kg1a[0];
+		if (k!=PROGRAM1000_KGA_NONE){
+			if (fp->type==AKAI_PROGRAM3000_FTYPE){
+				k*=PROGRAM3000_KGA_MULT;
+				PRINTF_OUT("kg1a:      0x%05x\n",k);
+			}else{
+				PRINTF_OUT("kg1a:      0x%04x\n",k);
+			}
+		}
+		for (i=0;i<kgnum;i++){
+			PRINTF_OUT("keygroup %u:\n",i+1);
+			s3000kgp=(struct akai_program3000kg_s *)(buf+hdrsiz+i*kgsiz);
+			PRINTF_OUT("  key lo-hi: %u-%u\n",s3000kgp->s1000.keylo,s3000kgp->s1000.keyhi);
+			PRINTF_OUT("  ctune:     %+i\n",(int)(char)s3000kgp->s1000.ctune);
+			PRINTF_OUT("  stune:     %+i\n",(int)(char)s3000kgp->s1000.stune);
+			PRINTF_OUT("  filter:    %u\n",s3000kgp->s1000.filter);
+			PRINTF_OUT("  velxf:     %s\n",(s3000kgp->s1000.velxf!=0x00)?"ON":"OFF");
+			for (j=0;j<PROGRAM1000KG_VELZONENUM;j++){
+				PRINTF_OUT("  velzone %u:\n",j+1);
+				akai2ascii_name(s3000kgp->s1000.velzone[j].sname,nbuf,0); /* 0: not S900 */
+				PRINTF_OUT("    vel lo-hi: %u-%u\n",s3000kgp->s1000.velzone[j].vello,s3000kgp->s1000.velzone[j].velhi);
+				PRINTF_OUT("    ctune:     %+i\n",(int)(char)s3000kgp->s1000.velzone[j].ctune);
+				PRINTF_OUT("    stune:     %+i\n",(int)(char)s3000kgp->s1000.velzone[j].stune);
+				PRINTF_OUT("    loud:      %+i\n",(int)(char)s3000kgp->s1000.velzone[j].loud);
+				PRINTF_OUT("    filter:    %+i\n",(int)(char)s3000kgp->s1000.velzone[j].filter);
+				PRINTF_OUT("    pan:       %+i\n",(int)(char)s3000kgp->s1000.velzone[j].pan);
+				PRINTF_OUT("    auxchoff:  %u\n",s3000kgp->s1000.auxchoff[j]);
+				PRINTF_OUT("    pitch:     %s\n",(s3000kgp->s1000.pconst[j]!=0x00)?"CONST":"TRACK");
+				PRINTF_OUT("    pmode:     ");
+				switch (s3000kgp->s1000.velzone[j].pmode){
+				case PROGRAM1000_PMODE_SAMPLE:
+					PRINTF_OUT("SAMPLE\n");
+					break;
+				case PROGRAM1000_PMODE_LOOP:
+					PRINTF_OUT("LOOP\n");
+					break;
+				case PROGRAM1000_PMODE_LOOPNOTREL:
+					PRINTF_OUT("LOOPNOTREL\n");
+					break;
+				case PROGRAM1000_PMODE_NOLOOP:
+					PRINTF_OUT("NOLOOP\n");
+					break;
+				case PROGRAM1000_PMODE_TOEND:
+					PRINTF_OUT("TOEND\n");
+					break;
+				default:
+					PRINTF_OUT("\?\?\?\n");
+					break;
+				}
+				PRINTF_OUT("    sname:     \"%s\"\n",nbuf);
+				k=(s3000kgp->s1000.velzone[j].shdra[1]<<8)+s3000kgp->s1000.velzone[j].shdra[0];
+				if (k!=PROGRAM1000KG_SHDRA_NONE){
+					if (fp->type==AKAI_PROGRAM3000_FTYPE){
+						k*=PROGRAM3000_SHDRA_MULT;
+						PRINTF_OUT("    shdra:     0x%05x\n",k);
+					}else{
+						PRINTF_OUT("    shdra:     0x%04x\n",k);
+					}
+				}
+			}
+			k=(s3000kgp->s1000.kgnexta[1]<<8)+s3000kgp->s1000.kgnexta[0];
+			if (k!=PROGRAM1000_KGA_NONE){
+				if (fp->type==AKAI_PROGRAM3000_FTYPE){
+					k*=PROGRAM3000_KGA_MULT;
+					PRINTF_OUT("  kgnexta:   0x%05x\n",k);
+				}else{
+					PRINTF_OUT("  kgnexta:   0x%04x\n",k);
+				}
+			}
+		}
+	}
+
+	free(buf);
+	return 0;
+}
+
+int
+akai_cuelist_info(struct file_s *fp)
+{
+	static char nbuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	struct akai_cuelist_s *hdrp;
+	struct akai_cue_s *cuep;
+	u_char *buf;
+	u_int cuenum;
+	char *tname;
+	u_int i;
+
+	if ((fp==NULL)||(fp->volp==NULL)||(fp->index>=fp->volp->fimax)){
+		return -1;
+	}
+
+	/* allocate buffer */
+	if (fp->size<sizeof(struct akai_cuelist_s)){
+		PRINTF_ERR("invalid file size\n");
+		return -1;
+	}
+	if ((buf=(u_char *)malloc(fp->size))==NULL){
+		PRINTF_ERR("cannot allocate memory\n");
+		return -1;
+	}
+
+	/* read file */
+	if (akai_read_file(0,buf,fp,0,fp->size)<0){
+		PRINTF_ERR("cannot read file\n");
+		free(buf);
+		return -1;
+	}
+
+	hdrp=(struct akai_cuelist_s *)buf;
+	cuenum=(u_int)hdrp->cuenum;
+	PRINTF_OUT("cuenum:  %u\n",cuenum);
+	if (fp->size<sizeof(struct akai_cuelist_s)+cuenum*sizeof(struct akai_cue_s)){
+		PRINTF_ERR("invalid file size\n");
+		free(buf);
+		return -1;
+	}
+
+	if (cuenum>0){
+		/* cues */
+		PRINTF_OUT("\ncue  time           type  name          mnote mvel  lvl  pan\n");
+		PRINTF_OUT("------------------------------------------------------------\n");
+		for (i=0;i<cuenum;i++){
+			cuep=(struct akai_cue_s *)(buf+sizeof(struct akai_cuelist_s)+i*sizeof(struct akai_cue_s));
+			akai2ascii_name(cuep->name,nbuf,0); /* 0: not S900 */
+			switch (cuep->type){
+			case AKAI_CUETYPE_MOFF:
+				tname="MOFF";
+				break;
+			case AKAI_CUETYPE_MON:
+				tname="MON ";
+				break;
+			case AKAI_CUETYPE_TOFF:
+				tname="TOFF";
+				break;
+			case AKAI_CUETYPE_TON:
+				tname="TON ";
+				break;
+			default:
+				tname="\?\?\? ";
+				break;
+			}
+			PRINTF_OUT("%3u  %02x:%02x:%02x:%02x.%x  %s  %-12s    ",
+				i+1,
+				(u_int)cuep->time[4],
+				(u_int)cuep->time[3],
+				(u_int)cuep->time[2],
+				(u_int)cuep->time[1],
+				(u_int)(cuep->time[0]>>4),
+				tname,
+				nbuf);
+			if ((cuep->type==AKAI_CUETYPE_MOFF)||(cuep->type==AKAI_CUETYPE_MON)){
+				PRINTF_OUT("%3u  %3u\n",
+					(u_int)cuep->midinote,
+					(u_int)cuep->midivel);
+			}else if ((cuep->type==AKAI_CUETYPE_TOFF)||(cuep->type==AKAI_CUETYPE_TON)){
+				PRINTF_OUT("          %3u  %+3i\n",
+					(u_int)cuep->stlvl,
+					(int)(char)cuep->pan);
+			}else{
+				PRINTF_OUT("\n");
+			}
+		}
+		PRINTF_OUT("------------------------------------------------------------\n");
+	}
+
+	free(buf);
+	return 0;
+}
+
+int
+akai_takelist_info(struct file_s *fp)
+{
+	static char nbuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	struct akai_cuelist_s *hdrp;
+	struct akai_cue_s *cuep;
+	u_char *buf;
+	u_int cuenum;
+	u_int i;
+
+	if ((fp==NULL)||(fp->volp==NULL)||(fp->index>=fp->volp->fimax)){
+		return -1;
+	}
+
+	/* allocate buffer */
+	if (fp->size<sizeof(struct akai_cuelist_s)){
+		PRINTF_ERR("invalid file size\n");
+		return -1;
+	}
+	if ((buf=(u_char *)malloc(fp->size))==NULL){
+		PRINTF_ERR("cannot allocate memory\n");
+		return -1;
+	}
+
+	/* read file */
+	if (akai_read_file(0,buf,fp,0,fp->size)<0){
+		PRINTF_ERR("cannot read file\n");
+		free(buf);
+		return -1;
+	}
+
+	hdrp=(struct akai_cuelist_s *)buf;
+	cuenum=(u_int)hdrp->cuenum;
+	PRINTF_OUT("cuenum:  %u\n",cuenum);
+	if (fp->size<sizeof(struct akai_cuelist_s)+cuenum*sizeof(struct akai_cue_s)){
+		PRINTF_ERR("invalid file size\n");
+		free(buf);
+		return -1;
+	}
+
+	if (cuenum>0){
+		/* cues */
+		PRINTF_OUT("\ncue  rep  name          mnote  mch  lvl  pan  fadein fadeout\n");
+		PRINTF_OUT("------------------------------------------------------------\n");
+		for (i=0;i<cuenum;i++){
+			cuep=(struct akai_cue_s *)(buf+sizeof(struct akai_cuelist_s)+i*sizeof(struct akai_cue_s));
+			akai2ascii_name(cuep->name,nbuf,0); /* 0: not S900 */
+			PRINTF_OUT("%3u  %3u  %-12s    %3u  %3u  %3u  %+3i   %5u   %5u\n",
+				i+1,
+				((u_int)cuep->repeat1)+1,
+				nbuf,
+				(u_int)cuep->midinote,
+				((u_int)cuep->midich1)+1,
+				(u_int)cuep->stlvl,
+				(int)(char)cuep->pan,
+				(((u_int)cuep->fadein[1])<<8)|((u_int)cuep->fadein[0]),
+				(((u_int)cuep->fadeout[1])<<8)|((u_int)cuep->fadeout[0]));
+		}
+		PRINTF_OUT("------------------------------------------------------------\n");
+	}
+
+	free(buf);
+	return 0;
+}
+
+int
+akai_drum1000_info(struct file_s *fp)
+{
+	struct akai_drum1000_s *dfp;
+	struct akai_drum1000des_s *ddp;
+	u_char *buf;
+	u_int i,j;
+
+	if ((fp==NULL)||(fp->volp==NULL)||(fp->index>=fp->volp->fimax)){
+		return -1;
+	}
+
+	/* allocate buffer */
+	if (fp->size<sizeof(struct akai_drum1000_s)){
+		PRINTF_ERR("invalid file size\n");
+		return -1;
+	}
+	if ((buf=(u_char *)malloc(fp->size))==NULL){
+		PRINTF_ERR("cannot allocate memory\n");
+		return -1;
+	}
+
+	/* read file */
+	if (akai_read_file(0,buf,fp,0,fp->size)<0){
+		PRINTF_ERR("cannot read file\n");
+		free(buf);
+		return -1;
+	}
+
+	dfp=(struct akai_drum1000_s *)buf;
+	ddp=dfp->ddes1; /* for ME35T unit 1 */
+	for (i=0;i<DRUM1000_UNITNUM;i++){
+		PRINTF_OUT("\nS1000/S3000 drum settings for ME35T unit %u:\n",i+1);
+		PRINTF_OUT("inp midich mnote  sens  trig vcurv captt recovt ontime\n");
+		PRINTF_OUT("------------------------------------------------------\n");
+		for (j=0;j<DRUM1000_INPUTNUM;j++){
+			PRINTF_OUT("%3u    %3u   %3u   %3u   %3u  %3u  %3ums  %3ums  %3ums\n",
+				j+1,
+				((u_int)ddp->midich1)+1,
+				(u_int)ddp->midinote,
+				(u_int)ddp->sens,
+				(u_int)ddp->trig,
+				((u_int)ddp->vcurv1)+1,
+				(u_int)ddp->captt,
+				(u_int)ddp->recovt,
+				(u_int)ddp->ontime);
+		}
+		PRINTF_OUT("------------------------------------------------------\n");
+		ddp=dfp->ddes2; /* for ME35T unit 2 */
+	}
+
+	free(buf);
+	return 0;
+}
+
+int
+akai_drum900_info(struct file_s *fp)
+{
+	struct akai_drum900_s *dfp;
+	struct akai_drum900des_s *ddp;
+	u_char *buf;
+	u_int captt,ontime,recovt;
+	u_int j;
+
+	if ((fp==NULL)||(fp->volp==NULL)||(fp->index>=fp->volp->fimax)){
+		return -1;
+	}
+
+	/* allocate buffer */
+	if (fp->size<sizeof(struct akai_drum900_s)){
+		PRINTF_ERR("invalid file size\n");
+		return -1;
+	}
+	if ((buf=(u_char *)malloc(fp->size))==NULL){
+		PRINTF_ERR("cannot allocate memory\n");
+		return -1;
+	}
+
+	/* read file */
+	if (akai_read_file(0,buf,fp,0,fp->size)<0){
+		PRINTF_ERR("cannot read file\n");
+		free(buf);
+		return -1;
+	}
+
+	dfp=(struct akai_drum900_s *)buf;
+	PRINTF_OUT("ASK90 enable:      %s\n",dfp->ask90enab?"ON":"OFF");
+	PRINTF_OUT("ASK90 sensitivity: %s\n",dfp->ask90sens?"HIGH":"LOW");
+	PRINTF_OUT("\nS900/S950 drum settings for ASK90/ME35T:\n");
+	PRINTF_OUT("itype inp midich mnote  gain  trig vcurv captt ontime recovt resetba   adcla\n");
+	PRINTF_OUT("----------------------------------------------------------------------------\n");
+	for (j=0;j<DRUM900_INPUTNUM;j++){
+		ddp=&dfp->ddes[j];
+		captt=((ddp->captt4[1]<<8)+ddp->captt4[0])>>2;
+		ontime=((ddp->ontime4[1]<<8)+ddp->ontime4[0])>>2;
+		recovt=((ddp->recovt4[1]<<8)+ddp->recovt4[0])>>2;
+		if (ddp->itype==DRUM900DES_ITYPE_ME35T){
+			/* for ME35T */
+			PRINTF_OUT("ME35T %3u    %3u   %3u   %3u   %3u  %3u  %3ums  %3ums  %3ums       -       -\n",
+				((u_int)ddp->inpnr1)+1,
+				((u_int)ddp->midich1)+1,
+				(u_int)ddp->midinote,
+				(u_int)ddp->gain,
+				(u_int)ddp->me35t_trig,
+				((u_int)ddp->me35t_vcurv1)+1,
+				captt,
+				ontime,
+				recovt);
+		}else{
+			/* for ASK90 */
+			PRINTF_OUT("ASK90 %3u    %3u   %3u   %3u   %3u    -  %3ums  %3ums  %3ums  0x%02x%02x  0x%02x%02x\n",
+				((u_int)ddp->inpnr1)+1,
+				((u_int)ddp->midich1)+1,
+				(u_int)ddp->midinote,
+				(u_int)ddp->gain,
+				(u_int)ddp->ask90_trig,
+				captt,
+				ontime,
+				recovt,
+				(u_int)ddp->ask90_resba[1],(u_int)ddp->ask90_resba[0],
+				(u_int)ddp->ask90_adcla[1],(u_int)ddp->ask90_adcla[0]);
+		}
+	}
+	PRINTF_OUT("----------------------------------------------------------------------------\n");
+
+	free(buf);
+	return 0;
+}
+
+int
+akai_ovs900_info(struct file_s *fp)
+{
+	static char nbuf[AKAI_NAME_LEN_S900+1]; /* +1 for '\0' */
+	struct akai_ovs900_s *ofp;
+	u_char *buf;
+	u_int i;
+
+	if ((fp==NULL)||(fp->volp==NULL)||(fp->index>=fp->volp->fimax)){
+		return -1;
+	}
+
+	/* allocate buffer */
+	if (fp->size<sizeof(struct akai_ovs900_s)){
+		PRINTF_ERR("invalid file size\n");
+		return -1;
+	}
+	if ((buf=(u_char *)malloc(fp->size))==NULL){
+		PRINTF_ERR("cannot allocate memory\n");
+		return -1;
+	}
+
+	/* read file */
+	if (akai_read_file(0,buf,fp,0,fp->size)<0){
+		PRINTF_ERR("cannot read file\n");
+		free(buf);
+		return -1;
+	}
+
+	ofp=(struct akai_ovs900_s *)buf;
+	akai2ascii_name((u_char *)ofp->progname,nbuf,1); /* 1: S900 */
+	PRINTF_OUT("selected program name: \"%s\"\n",nbuf);
+	i=(ofp->testmidich[1]<<8)+ofp->testmidich[0];
+	PRINTF_OUT("test MIDI channel:     %u\n",i);
+	i=(ofp->testmidikey[1]<<8)+ofp->testmidikey[0];
+	PRINTF_OUT("test MIDI key:         %u\n",i);
+	i=(ofp->testmidivel[1]<<8)+ofp->testmidivel[0];
+	PRINTF_OUT("test MIDI velocity:    %u\n",i);
+	PRINTF_OUT("basic MIDI channel:    %u\n",((u_int)(OVS900_BMIDICH1MASK&ofp->bmidich1omni))+1);
+	PRINTF_OUT("MIDI OMNI:             %s\n",(OVS900_OMNIMASK&ofp->bmidich1omni)?"ON":"OFF");
+	PRINTF_OUT("loudness:              %s\n",ofp->loudness?"ON":"OFF");
+	PRINTF_OUT("control port:          ");
+	switch (ofp->ctrlport){
+	case OVS900_CTRLPORT_MIDI:
+		PRINTF_OUT("MIDI\n");
+		break;
+	case OVS900_CTRLPORT_RS232:
+		PRINTF_OUT("RS232\n");
+		break;
+	default:
+		PRINTF_OUT("\?\?\?\n");
+		break;
+	}
+	PRINTF_OUT("program change:        %s\n",ofp->progchange?"ON":"OFF");
+	PRINTF_OUT("pitch wheel range:     %u\n",(u_int)ofp->pwheelrange);
+	i=((ofp->rs232brate10[1]<<8)+ofp->rs232brate10[0])*10;
+	PRINTF_OUT("RS232 baudrate:        %u\n",i);
+
+	free(buf);
+	return 0;
+}
+
+int
+akai_cdsetup3000_info(struct file_s *fp)
+{
+	char nbuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	u_char *buf;
+	struct akai_cdsetup3000_s *hp;
+	struct akai_cdsetup3000_entry_s *ep;
+	u_int enr;
+	u_int e,i;
+
+	if ((fp==NULL)||(fp->volp==NULL)||(fp->index>=fp->volp->fimax)){
+		return -1;
+	}
+
+	/* allocate buffer */
+	if (fp->size<sizeof(struct akai_cdsetup3000_s)){
+		PRINTF_ERR("invalid file size\n");
+		return -1;
+	}
+	if ((buf=(u_char *)malloc(fp->size))==NULL){
+		PRINTF_ERR("cannot allocate memory\n");
+		return -1;
+	}
+
+	/* header */
+	hp=(struct akai_cdsetup3000_s *)buf;
+	/* marked file entries */
+	ep=(struct akai_cdsetup3000_entry_s *)(buf+sizeof(struct akai_cdsetup3000_s));
+	/* number of entries */
+	enr=(fp->size-sizeof(struct akai_cdsetup3000_s))/sizeof(struct akai_cdsetup3000_entry_s);
+
+	/* read file */
+	if (akai_read_file(0,buf,fp,0,fp->size)<0){
+		PRINTF_ERR("cannot read file\n");
+		free(buf);
+		return -1;
+	}
+
+	/* name */
+	akai2ascii_name(hp->name,nbuf,fp->volp->type==AKAI_VOL_TYPE_S900);
+	PRINTF_OUT("ramname: \"%s\"\n\n",nbuf);
+
+	/* CD-ROM label */
+	akai2ascii_name(hp->cdlabel,nbuf,fp->volp->type==AKAI_VOL_TYPE_S900);
+	PRINTF_OUT("CD-ROM label: \"%s\"\n",nbuf);
+
+	/* print marked file entries */
+	PRINTF_OUT("\nmarked files (part:vol/file):\n---------------------------------------------\n");
+	i=0;
+	for (e=0;e<enr;e++){
+		if (ep[e].parti!=0xff){ /* used entry? */
+			PRINTF_OUT("%c:%03u/%03u   ",
+				'A'+ep[e].parti,
+				ep[e].voli+1,
+				(ep[e].filei[1]<<8)+ep[e].filei[0]+1);
+			if (i%4==3){
+				PRINTF_OUT("\n");
+			}
+			i++;
+		}
+	}
+	if (i%4!=0){
+		PRINTF_OUT("\n");
+	}
+	PRINTF_OUT("---------------------------------------------\n");
+
+	free(buf);
+	return 0;
+}
+
+
+
+/* fix RAM name of AKAI file */
+int
+akai_fixramname(struct file_s *fp)
+{
+	static char nbuf[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	static u_char buf[sizeof(struct akai_genfilehdr_s)]; /* XXX enough for all cases */
+	u_char *np;
+	int s900flag;
+
+	if ((fp==NULL)||(fp->volp==NULL)||(fp->index>=fp->volp->fimax)){
+		return -1;
+	}
+
+	/* file type */
+	s900flag=0; /* default */
+	switch (fp->type){
+	case AKAI_SAMPLE900_FTYPE: /* S900 sample */
+	case AKAI_PROGRAM900_FTYPE: /* S900 program */
+		/* Note: name in S900 sample/program file header starts at byte 0 */
+		np=buf;
+		s900flag=1;
+		break;
+	case AKAI_SAMPLE1000_FTYPE: /* S1000 sample */
+	case AKAI_SAMPLE3000_FTYPE: /* S3000 sample */
+	case AKAI_CDSAMPLE3000_FTYPE: /* CD3000 CD-ROM sample parameters */
+	case AKAI_PROGRAM1000_FTYPE: /* S1000 program */
+	case AKAI_PROGRAM3000_FTYPE: /* S3000 program */
+	case AKAI_DRUM1000_FTYPE: /* S1000 or S3000 drum settings file */
+	case AKAI_FXFILE_FTYPE: /* S1100 or S3000 effects file */
+	case AKAI_QLFILE_FTYPE: /* S1100 or S3000 cue-list file */
+	case AKAI_TLFILE_FTYPE: /* S1100 or S3000 take-list file */
+	case AKAI_MULTI3000_FTYPE: /* S3000 multi file */
+		{
+			/* use generic file header */
+			struct akai_genfilehdr_s *p;
+			p=(struct akai_genfilehdr_s *)buf;
+			np=p->name;
+		}
+		break;
+	case AKAI_CDSETUP3000_FTYPE:
+		{
+			/* CD3000 CD-ROM setup file */
+			/* Note: generic file header does not apply for this file type! */
+			struct akai_cdsetup3000_s *p;
+			p=(struct akai_cdsetup3000_s *)buf;
+			np=p->name;
+		}
+		break;
+	default:
+		/* unknown or unsupported */
+		return 1; /* no error */
+	}
+
+	/* read header */
+	if (akai_read_file(0,buf,fp,0,sizeof(struct akai_genfilehdr_s))<0){
+		PRINTF_ERR("cannot read header\n");
+		return -1;
+	}
+
+	/* copy file name to name in RAM */
+	akai2ascii_name(fp->volp->file[fp->index].name,nbuf,fp->volp->type==AKAI_VOL_TYPE_S900);
+	ascii2akai_name(nbuf,np,s900flag);
+
+	/* write header */
+	if (akai_write_file(0,buf,fp,0,sizeof(struct akai_genfilehdr_s))<0){
+		PRINTF_ERR("cannot write header\n");
+		return -1;
+	}
+
+	return 0;
+};
+
+
+
+int
+akai_s900comprfile_updateuncompr(struct file_s *fp)
+{
+	u_int osver;
+
+	if (fp==NULL){
+		return -1;
+	}
+
+	/* check if compressed file in S900 volume */
+	if ((fp->volp==NULL)||(fp->volp->type!=AKAI_VOL_TYPE_S900)||(fp->osver==0)){
+		return -1;
+	}
+
+	/* check if supported file type */
+	if (fp->type!=AKAI_SAMPLE900_FTYPE){
+		/* no error, keep osver */
+		return 0;
+	}
+
+	/* S900 sample file, compressed sample format */
+	/* non-compressed sample size in bytes */
+	osver=akai_sample900_getsamplesize(fp);
+	/* number of un-compressed floppy blocks */
+	/* Note: without sample header */
+	osver=(osver+AKAI_FL_BLOCKSIZE-1)/AKAI_FL_BLOCKSIZE; /* round up */
+	if (osver==0){ /* unsuitable osver? */
+		osver=1; /* XXX non zero */
+	}
+
+	/* set osver of file */
+	/* Note: akai_rename_file() will correct osver if necessary */
+	if (akai_rename_file(fp,NULL,fp->volp,AKAI_CREATE_FILE_NOINDEX,NULL,osver)<0){
+		return -1;
+	}
+
+	return 0;
+}
+
+
+
+u_int
+akai_sample900_getsamplesize(struct file_s *fp)
+{
+	static struct akai_sample900_s s900hdr;
+	static u_int samplecount;
+	static u_int samplecountpart;
+	static u_int samplesize;
+
+	if (fp==NULL){
+		return 0;
+	}
+	if (fp->type!=(u_char)AKAI_SAMPLE900_FTYPE){ /* not S900 sample? */
+		return 0;
+	}
+
+	/* read header to memory */
+	if (akai_read_file(0,(u_char *)&s900hdr,fp,0,sizeof(struct akai_sample900_s))<0){
+		PRINTF_ERR("cannot read sample header\n");
+		return 0;
+	}
+
+	/* number of samples */
+	/* XXX should be an even number */
+	samplecount=(s900hdr.slen[3]<<24)
+		+(s900hdr.slen[2]<<16)
+		+(s900hdr.slen[1]<<8)
+		+s900hdr.slen[0];
+	/* number of samples per part  */
+	samplecountpart=(samplecount+1)/2; /* round up */
+	/* size in bytes in S900 non-compressed sample format */
+	samplesize=3*samplecountpart;
+	return samplesize;
+}
+
+
+
+void
+akai_sample900noncompr_sample2wav(u_char *sbuf,u_char *wavbuf,u_int samplecountpart)
+{
+	u_int i;
+
+	if ((sbuf==NULL)||(wavbuf==NULL)){
+		return;
+	}
+	if (samplecountpart==0){
+		return;
+	}
+
+	/* convert 12bit S900 non-compressed sample format into 16bit WAV sample format */
+	for (i=0;i<samplecountpart;i++){ /* first part */
+		wavbuf[i*2+1]=sbuf[i*2+1];
+		wavbuf[i*2+0]=0xf0&sbuf[i*2+0];
+	}
+	for (i=0;i<samplecountpart;i++){ /* second part */
+		wavbuf[samplecountpart*2+i*2+1]=sbuf[samplecountpart*2+i];
+		wavbuf[samplecountpart*2+i*2+0]=0xf0&(sbuf[i*2+0]<<4);
+	}
+}
+
+void
+akai_sample900noncompr_wav2sample(u_char *sbuf,u_char *wavbuf,u_int samplecountpart)
+{
+	u_int i;
+
+	if ((sbuf==NULL)||(wavbuf==NULL)){
+		return;
+	}
+	if (samplecountpart==0){
+		return;
+	}
+
+	/* convert 16bit WAV sample format into 12bit S900 non-compressed sample format */
+	for (i=0;i<samplecountpart;i++){ /* first part */
+		sbuf[i*2+1]=wavbuf[i*2+1];
+		sbuf[i*2+0]=0xf0&wavbuf[i*2+0];
+	}
+	for (i=0;i<samplecountpart;i++){ /* second part */
+		sbuf[samplecountpart*2+i]=wavbuf[samplecountpart*2+i*2+1];
+		sbuf[i*2+0]|=0x0f&(wavbuf[samplecountpart*2+i*2+0]>>4);
+	}
+}
+
+
+
+u_int
+akai_sample900compr_getbits(u_char *buf,u_int bitpos,u_int bitnum)
+{
+	u_int bytepos;
+	u_char bmask;
+	u_int val;
+	u_int i;
+
+	if ((buf==NULL)||(bitnum==0)){
+		return 0;
+	}
+	/* XXX no check if bitnum too large for u_int */
+	/* XXX no check if bitpos+bitnum too large for buf */
+
+	val=0;
+	for (i=0;i<bitnum;i++,bitpos++){
+		bytepos=(bitpos>>3); /* /8: 8 bits per byte */
+		bmask=(1<<(7-(7&bitpos))); /* Note: upper bit first */
+		val<<=1;
+		if ((bmask&buf[bytepos])!=0){
+			val|=1;
+		}
+	}
+
+	return val;
+}
+
+u_int
+akai_sample900compr_sample2wav(u_char *sbuf,u_char *wavbuf,u_int sbufsiz,u_int wavbufsiz)
+{
+	u_char upbitnum;
+	u_char upsign;
+	u_short upabsval;
+	short curval;
+	short curinc;
+	u_int bitremain;
+	u_int bitpos;
+	u_int wavpos;
+	u_char code;
+	u_int i,j;
+
+	if ((sbuf==NULL)||(wavbuf==NULL)){
+		return 0;
+	}
+	if ((sbufsiz==0)||(wavbufsiz==0)){
+		return 0;
+	}
+
+	/* convert S900 compressed sample format into 16bit WAV sample format */
+	curval=0;
+	curinc=0;
+	bitremain=sbufsiz*8; /* 8 bits per byte */
+	bitpos=0;
+	wavpos=0;
+	for (;(bitremain>0)&&(wavpos+1<wavbufsiz);){
+		/* get code nibble */
+		if (bitremain<4){
+			break; /* end */
+		}
+		code=(u_char)akai_sample900compr_getbits(sbuf,bitpos,4);
+#ifdef SAMPLE900COMPR_DEBUG
+		PRINTF_OUT("%08x: code=%x\n",bitpos,code);
+#endif
+		bitpos+=4;
+		bitremain-=4;
+		/* parse code */
+		if (code==0x0){
+			/* Note: no further bits for this group */
+			/* generate signal */
+			for (i=0;(i<SAMPLE900COMPR_GROUP_SAMPNUM)&&(wavpos+1<wavbufsiz);i++){
+				/* update curval */
+				curval+=curinc;
+				/* convert 12bit sample into 16bit WAV sample */
+				wavbuf[wavpos++]=0xf0&(u_char)(curval<<4);
+				wavbuf[wavpos++]=0xff&(u_char)(curval>>4);
+			}
+		}else{
+			/* number of bits for upabsval */
+			upbitnum=SAMPLE900COMPR_UPBITNUM_NEGCODE_OFF-code;
+			/* Note: upbitnum>SAMPLE900COMPR_UPBITNUM_MAX is supported here, but should not occur normally */
+#ifdef SAMPLE900COMPR_DEBUG
+			if (upbitnum>SAMPLE900COMPR_UPBITNUM_MAX){
+				PRINTF_OUT("          upbitnum>SAMPLE900COMPR_UPBITNUM_MAX\n");
+			}
+#endif
+			/* number of required remaining bits for instruction code */
+			j=SAMPLE900COMPR_GROUP_SAMPNUM*(1+((u_int)upbitnum)); /* Note: per word: 1 sign flag bit and n bits */
+			if (bitremain<j){
+				break; /* end */
+			}
+			/* generate signal */
+			for (i=0;(i<SAMPLE900COMPR_GROUP_SAMPNUM)&&(wavpos+1<wavbufsiz);i++){
+				/* get sign flag bit */
+				upsign=(u_char)akai_sample900compr_getbits(sbuf,bitpos+0+i,1);
+				/* get value word */
+				upabsval=(u_short)akai_sample900compr_getbits(sbuf,bitpos+SAMPLE900COMPR_GROUP_SAMPNUM+i*((u_int)upbitnum),(u_int)upbitnum);
+#ifdef SAMPLE900COMPR_DEBUG
+				PRINTF_OUT("          %c%u\n",(upsign==0)?'+':'-',(u_int)upabsval);
+#endif
+				/* update curinc */
+				if (upsign==0){
+					/* plus */
+					curinc+=(short)upabsval;
+				}else{
+					/* minus */
+					curinc-=(short)upabsval;
+				}
+				/* update curval */
+				curval+=curinc;
+				/* Note: SAMPLE900COMPR_BITMASK&curval contains sample value */
+				/* convert 12bit sample into 16bit WAV sample */
+				wavbuf[wavpos++]=0xf0&(u_char)(curval<<4);
+				wavbuf[wavpos++]=0xff&(u_char)(curval>>4);
+			}
+			bitpos+=j;
+			bitremain-=j;
+		}
+	}
+
+	return wavpos;
+}
+
+void
+akai_sample900compr_setbits(u_char *buf,u_int bitpos,u_int bitnum,u_int val)
+{
+	u_int bytepos;
+	u_char bmask;
+	u_int i;
+
+	if ((buf==NULL)||(bitnum==0)){
+		return;
+	}
+	/* XXX no check if bitnum too large for u_int */
+	/* XXX no check if bitpos+bitnum too large for buf */
+
+	for (i=0;i<bitnum;i++,bitpos++){
+		bytepos=(bitpos>>3); /* /8: 8 bits per byte */
+		bmask=(1<<(7-(7&bitpos))); /* Note: upper bit first */
+		if (((1<<(bitnum-1-i))&val)!=0){ /* bit set? (Note: upper bit first) */
+			/* set bit */
+			buf[bytepos]|=bmask;
+		}else{
+			/* clear bit */
+			buf[bytepos]&=~bmask;
+		}
+	}
+}
+
+int
+akai_sample900compr_wav2sample(u_char *sbuf,u_char *wavbuf,u_int samplecountpart)
+{
+	/* must be static for multiple calls, must be initialized */
+	static u_char *upbitnumbuf=NULL;
+	static u_int *upsignbuf=NULL;
+	static u_short *upabsvalbuf=NULL;
+	static u_int groupcount=0;
+
+	short sval;
+	short curval;
+	short curinc;
+	short upval;
+	u_short upabsval;
+	u_char upbitnum;
+	u_int upsign;
+	u_int bitpos;
+	u_char code;
+	u_int g,s,i,j;
+	int ret;
+
+	if ((sbuf==NULL)&&(wavbuf==NULL)){
+		ret=0; /* no error */
+		/* free buffers if still allocated */
+		goto akai_sample900compr_wav2sample_freebufexit;
+	}
+
+	ret=-1; /* no success so far */
+
+	/* convert 16bit WAV sample format into S900 compressed sample format */
+
+	if (sbuf==NULL){
+		/* first pass */
+
+		/* free buffers if still allocated */
+		if (upbitnumbuf!=NULL){
+			free(upbitnumbuf);
+			upbitnumbuf=NULL;
+		}
+		if (upsignbuf!=NULL){
+			free(upsignbuf);
+			upsignbuf=NULL;
+		}
+		if (upabsvalbuf!=NULL){
+			free(upabsvalbuf);
+			upabsvalbuf=NULL;
+		}
+
+		/* number of groups */
+		/* Note: 2*samplecountpart+1 to encode at least one additional zero sample behind end */
+		groupcount=(2*samplecountpart+1+SAMPLE900COMPR_GROUP_SAMPNUM-1)/SAMPLE900COMPR_GROUP_SAMPNUM; /* round up */
+
+		/* allocate buffers */
+		upbitnumbuf=(u_char *)malloc(groupcount*sizeof(u_char));
+		if (upbitnumbuf==NULL){
+			PERROR("cannot allocate upbitnumbuf");
+			goto akai_sample900compr_wav2sample_freebufexit;
+		}
+		upsignbuf=(u_int *)malloc(groupcount*sizeof(u_int));
+		if (upsignbuf==NULL){
+			PERROR("cannot allocate upsignbuf");
+			goto akai_sample900compr_wav2sample_freebufexit;
+		}
+		upabsvalbuf=(u_short *)malloc(groupcount*SAMPLE900COMPR_GROUP_SAMPNUM*sizeof(u_short));
+		if (upabsvalbuf==NULL){
+			PERROR("cannot allocate upabsvalbuf");
+			goto akai_sample900compr_wav2sample_freebufexit;
+		}
+
+		/* gather groups */
+		curval=0;
+		curinc=0;
+		sval=0;
+		for (g=0,s=0;g<groupcount;g++){
+			upbitnum=0;
+			upsign=0;
+			/* samples within group */
+			for (i=0;i<SAMPLE900COMPR_GROUP_SAMPNUM;i++,s++){
+				if (s<2*samplecountpart){
+					/* get 12bit sample from 16bit WAV sample */
+					sval=(((short)(char)wavbuf[s*2+1])<<4)+(((short)(u_char)wavbuf[s*2+0])>>4);
+				}else{
+					/* encode zero sample behind end */
+					sval=0;
+				}
+
+				/* determine required upsign,upabsval */
+				upsign<<=1;
+				upval=sval-(curval+curinc);
+				/* choose optimum interval position for min. abs. value */
+				while (upval>SAMPLE900COMPR_INTERVALSIZ2){
+					upval-=SAMPLE900COMPR_INTERVALSIZ;
+				}
+				while (upval<-SAMPLE900COMPR_INTERVALSIZ2){
+					upval+=SAMPLE900COMPR_INTERVALSIZ;
+				}
+				/* Note: max./min. possible value for resulting upval is +/-SAMPLE900COMPR_INTERVALSIZ2 */
+				/*       which requires SAMPLE900COMPR_UPBITNUM_MAX bits for upabsval */
+				if (upval>=0){
+					/* plus */
+					/* upsign|=0; */
+					upabsval=SAMPLE900COMPR_BITMASK&(u_short)upval;
+					/* update curinc */
+					curinc+=(short)upabsval;
+				}else{
+					/* minus */
+					upsign|=1;
+					upabsval=SAMPLE900COMPR_BITMASK&(u_short)(-upval);
+					/* update curinc */
+					curinc-=(short)upabsval;
+				}
+				upabsvalbuf[s]=upabsval;
+
+				/* determine max. number of required bits for upabsval in group */
+				/* start with previous upbitnum */
+				for (j=(u_int)upbitnum;j<SAMPLE900COMPR_UPBITNUM_MAX;j++){
+					if (((1<<j)&upabsval)!=0){ /* bit j set? */
+						upbitnum=(u_char)(j+1);
+					}
+				}
+
+				/* update curval */
+				curval+=curinc;
+				/* Note: SAMPLE900COMPR_BITMASK&curval contains sample value */
+				if ((SAMPLE900COMPR_BITMASK&(curval-sval))!=0){
+					/* XXX should not happen */
+					PRINTF_ERR("%06x,%02x: error: sval=%i curval=%i\n",g,i,sval,curval);
+					goto akai_sample900compr_wav2sample_freebufexit;
+				}
+			}
+#ifdef SAMPLE900COMPR_DEBUG
+			PRINTF_OUT("%06x: upbitnum=%2u upsign=%04x\n",g,(u_int)upbitnum,upsign);
+#endif
+			upbitnumbuf[g]=upbitnum;
+			upsignbuf[g]=upsign;
+		}
+
+		/* determine number of bits required in sbuf for second pass */
+		bitpos=0;
+		for (g=0;g<groupcount;g++){
+			/* see "encode groups" below */
+			bitpos+=4;
+			if (upbitnumbuf[g]!=0){
+				bitpos+=SAMPLE900COMPR_GROUP_SAMPNUM*(1+((u_int)upbitnumbuf[g]));
+			}
+		}
+		bitpos+=(7&(8-(7&bitpos))); /* number of bits missing to full byte */
+
+		ret=(int)(bitpos>>3); /* success, return number of required bytes in sbuf for second pass */
+		/* keep buffers for second pass */
+		goto akai_sample900compr_wav2sample_keepbufexit;
+	}else{
+		/* second pass */
+
+		if (wavbuf==NULL){
+			goto akai_sample900compr_wav2sample_freebufexit;
+		}
+
+		/* check allocation of buffers */
+		if ((upbitnumbuf==NULL)||(upsignbuf==NULL)||(upabsvalbuf==NULL)){
+			PRINTF_ERR("error: buffers not allocated in second pass\n");
+			goto akai_sample900compr_wav2sample_freebufexit;
+		}
+
+		/* XXX ignore samplecountpart in second pass */
+
+		/* encode groups */
+		bitpos=0;
+		for (g=0,s=0;g<groupcount;g++){
+			/* determine code nibble */
+			upbitnum=upbitnumbuf[g];
+			if (upbitnum==0){
+				code=0x0;
+			}else{
+				code=SAMPLE900COMPR_UPBITNUM_NEGCODE_OFF-upbitnum;
+			}
+#ifdef SAMPLE900COMPR_DEBUG
+			PRINTF_OUT("%08x: code=%x\n",bitpos,code);
+#endif
+			/* save code nibble */
+			akai_sample900compr_setbits(sbuf,bitpos,4,(u_int)code);
+			bitpos+=4;
+
+			if (upbitnum==0){
+				s+=SAMPLE900COMPR_GROUP_SAMPNUM; /* advance in upabsvalbuf[] */
+				/* no further bits to save for this group */
+			}else{
+				/* save upsign */
+				upsign=upsignbuf[g];
+				akai_sample900compr_setbits(sbuf,bitpos,SAMPLE900COMPR_GROUP_SAMPNUM,upsign);
+				bitpos+=SAMPLE900COMPR_GROUP_SAMPNUM;
+				/* samples within group */
+				for (i=0;i<SAMPLE900COMPR_GROUP_SAMPNUM;i++,s++){
+					/* save upabsval */
+					upabsval=upabsvalbuf[s];
+					akai_sample900compr_setbits(sbuf,bitpos,(u_int)upbitnum,(u_int)upabsval);
+					bitpos+=(u_int)upbitnum;
+#ifdef SAMPLE900COMPR_DEBUG
+					PRINTF_OUT("          %c%u\n",
+						(((1<<(SAMPLE900COMPR_GROUP_SAMPNUM-1-i))&upsign)==0)?'+':'-',(u_int)upabsval); /* Note: upper bit first */
+#endif
+				}
+			}
+		}
+		j=(7&(8-(7&bitpos))); /* number of bits missing to full byte */
+		if (j!=0){
+			/* zero padding to full byte */
+			akai_sample900compr_setbits(sbuf,bitpos,j,0);
+			bitpos+=j;
+		}
+
+		ret=(int)(bitpos>>3); /* success, return number of used bytes in sbuf */
+		/* free buffers */
+		goto akai_sample900compr_wav2sample_freebufexit;
+	}
+
+akai_sample900compr_wav2sample_freebufexit:
+	if (upbitnumbuf!=NULL){
+		free(upbitnumbuf);
+		upbitnumbuf=NULL;
+	}
+	if (upsignbuf!=NULL){
+		free(upsignbuf);
+		upsignbuf=NULL;
+	}
+	if (upabsvalbuf!=NULL){
+		free(upabsvalbuf);
+		upabsvalbuf=NULL;
+	}
+
+akai_sample900compr_wav2sample_keepbufexit:
+	return ret;
+}
+
+
+
+int
+akai_sample900_compr2noncompr(struct file_s *fp,struct vol_s *volp)
+{
+	struct file_s tmpfile;
+	struct akai_sample900_s s900hdr;
+	u_int samplecount;
+	u_int samplecountpart;
+	u_int samplesizecompr;
+	u_char *sbufcompr;
+	u_int samplesizenoncompr;
+	u_char *sbufnoncompr;
+	u_int wavsamplesize;
+	u_char *wavbuf;
+	static char fname[AKAI_NAME_LEN_S900+3+1]; /* name (ASCII), +3 for ".S9", +1 for '\0' */
+	int replaceflag;
+	u_int findex;
+	u_int i;
+	int ret;
+
+	if (fp==NULL){
+		return -1;
+	}
+
+	if (volp==NULL){
+		/* destination volume same as source volume */
+		volp=fp->volp;
+		replaceflag=1; /* replace file */
+	}else{
+		replaceflag=0; /* keep source file */
+	}
+	if ((volp==NULL)||(volp->partp==NULL)){
+		return -1;
+	}
+
+	/* file type */
+	if ((fp->type!=(u_char)AKAI_SAMPLE900_FTYPE)||(fp->osver==0)){ /* not S900 compressed sample file? */
+		PRINTF_ERR("not an S900 compressed sample file\n");
+		return -1;
+	}
+	if (fp->size<sizeof(struct akai_sample900_s)){
+		PRINTF_ERR("invalid sample size\n");
+		return -1;
+	}
+
+	sbufcompr=NULL; /* no sample so far */
+	sbufnoncompr=NULL; /* no sample so far */
+	wavbuf=NULL; /* no sample so far */
+	ret=-1; /* no success so far */
+
+	/* read header to memory */
+	if (akai_read_file(0,(u_char *)&s900hdr,fp,0,sizeof(struct akai_sample900_s))<0){
+		PRINTF_ERR("cannot read sample\n");
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	/* number of samples */
+	/* XXX should be an even number */
+	samplecount=(s900hdr.slen[3]<<24)
+		+(s900hdr.slen[2]<<16)
+		+(s900hdr.slen[1]<<8)
+		+s900hdr.slen[0];
+	/* number of samples per part  */
+	samplecountpart=(samplecount+1)/2; /* round up */
+	/* size in bytes in S900 non-compressed sample format */
+	samplesizenoncompr=3*samplecountpart;
+	/* WAV size in bytes */
+	wavsamplesize=2*samplecountpart*2; /* *2 for 16bit per WAV sample word */
+	/* S900 compressed sample size */
+	samplesizecompr=fp->size-sizeof(struct akai_sample900_s);
+
+	/* create non-compressed sample file name */
+	/* Note: use RAM name as basis (-> akai_fixramname() not needed afterwards) */
+	akai2ascii_name((u_char *)s900hdr.name,fname,1); /* 1: S900 */
+	strcat(fname,".S9");
+
+	/* check if destination file already exists */
+	if (akai_find_file(volp,&tmpfile,fname)==0){
+		/* exists */
+		PRINTF_ERR("destination file name \"%s\" already used\n",fname);
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	/* check if enough free blocks */
+	/* required size of non-compressed file in blocks */
+	i=(sizeof(struct akai_sample900_s)+samplesizenoncompr+volp->partp->blksize-1)/volp->partp->blksize;
+	if (replaceflag){
+		if (samplesizecompr<samplesizenoncompr){
+			/* subtract size of existing compressed file in blocks */
+			i-=(sizeof(struct akai_sample900_s)+samplesizecompr+volp->partp->blksize-1)/volp->partp->blksize;
+		}else{
+			i=0;
+		}
+	}
+	if (volp->partp->bfree<i){
+		/* not enough space left */
+		PRINTF_ERR("not enough space left for destination file \"%s\"\n",fname);
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	/* allocate compressed sample buffer */
+	sbufcompr=(u_char *)malloc(samplesizecompr);
+	if (sbufcompr==NULL){
+		PRINTF_ERR("cannot allocate compressed sample buffer\n");
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	/* allocate non-compressed sample buffer */
+	sbufnoncompr=(u_char *)malloc(samplesizenoncompr);
+	if (sbufnoncompr==NULL){
+		PRINTF_ERR("cannot allocate non-compressed sample buffer\n");
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	/* allocate WAV sample buffer */
+	wavbuf=(u_char *)malloc(wavsamplesize);
+	if (wavbuf==NULL){
+		PRINTF_ERR("cannot allocate WAV buffer\n");
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	/* read compressed sample to memory */
+	if (akai_read_file(0,sbufcompr,fp,sizeof(struct akai_sample900_s),sizeof(struct akai_sample900_s)+samplesizecompr)<0){
+		PRINTF_ERR("cannot read sample\n");
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	/* convert S900 compressed sample format into 16bit WAV sample format */
+	i=akai_sample900compr_sample2wav(sbufcompr,wavbuf,samplesizecompr,wavsamplesize);
+	if (i<wavsamplesize){
+		PRINTF_ERR("warning: incomplete sample data\n");
+		/* zero padding */
+		bzero(wavbuf+i,wavsamplesize-i);
+	}
+
+	/* convert 16bit WAV sample format into S900 non-compressed sample format */
+	akai_sample900noncompr_wav2sample(sbufnoncompr,wavbuf,samplecountpart);
+
+	if (replaceflag){
+		/* keep file index */
+		findex=fp->index;
+		/* delete source file */
+		if (akai_delete_file(fp)<0){
+			PRINTF_ERR("cannot overwrite existing file\n");
+			goto akai_sample900_compr2noncompr_exit;
+		}
+	}else{
+		findex=AKAI_CREATE_FILE_NOINDEX;
+	}
+	/* create file */
+	/* Note: akai_create_file() will correct osver if necessary */
+	if (akai_create_file(volp,&tmpfile,
+						 sizeof(struct akai_sample900_s)+samplesizenoncompr,
+						 findex,
+						 fname,
+						 0, /* non-compressed */
+						 NULL)<0){
+		PRINTF_ERR("cannot create file\n");
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	/* write sample header */
+	if (akai_write_file(0,(u_char *)&s900hdr,&tmpfile,0,sizeof(struct akai_sample900_s))<0){
+		PRINTF_ERR("cannot write sample header\n");
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	/* write non-compressed sample */
+	if (akai_write_file(0,sbufnoncompr,&tmpfile,sizeof(struct akai_sample900_s),sizeof(struct akai_sample900_s)+samplesizenoncompr)<0){
+		PRINTF_ERR("cannot write sample\n");
+		goto akai_sample900_compr2noncompr_exit;
+	}
+
+	ret=0; /* success */
+
+akai_sample900_compr2noncompr_exit:
+	if (sbufcompr!=NULL){
+		free(sbufcompr);
+	}
+	if (sbufnoncompr!=NULL){
+		free(sbufnoncompr);
+	}
+	if (wavbuf!=NULL){
+		free(wavbuf);
+	}
+	return ret;
+}
+
+int
+akai_sample900_noncompr2compr(struct file_s *fp,struct vol_s *volp)
+{
+	struct file_s tmpfile;
+	struct akai_sample900_s s900hdr;
+	u_int samplecount;
+	u_int samplecountpart;
+	u_int samplesizecompr;
+	u_char *sbufcompr;
+	u_int samplesizenoncompr;
+	u_char *sbufnoncompr;
+	u_int wavsamplesize;
+	u_char *wavbuf;
+	static char fname[AKAI_NAME_LEN_S900+4+1]; /* name (ASCII), +4 for ".S9C", +1 for '\0' */
+	int replaceflag;
+	u_int findex;
+	u_int osver;
+	u_int i;
+	int r;
+	int ret;
+
+	if (fp==NULL){
+		return -1;
+	}
+
+	if (volp==NULL){
+		/* destination volume same as source volume */
+		volp=fp->volp;
+		replaceflag=1; /* replace file */
+	}else{
+		replaceflag=0; /* keep source file */
+	}
+	if ((volp==NULL)||(volp->partp==NULL)){
+		return -1;
+	}
+
+	/* file type */
+	if ((fp->type!=(u_char)AKAI_SAMPLE900_FTYPE)||(fp->osver!=0)){ /* not S900 non-compressed sample file? */
+		PRINTF_ERR("not an S900 non-compressed sample file\n");
+		return -1;
+	}
+	if (fp->size<sizeof(struct akai_sample900_s)){
+		PRINTF_ERR("invalid sample size\n");
+		return -1;
+	}
+
+	sbufcompr=NULL; /* no sample so far */
+	sbufnoncompr=NULL; /* no sample so far */
+	wavbuf=NULL; /* no sample so far */
+	ret=-1; /* no success so far */
+
+	/* read header to memory */
+	if (akai_read_file(0,(u_char *)&s900hdr,fp,0,sizeof(struct akai_sample900_s))<0){
+		PRINTF_ERR("cannot read sample\n");
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	/* number of samples */
+	/* XXX should be an even number */
+	samplecount=(s900hdr.slen[3]<<24)
+		+(s900hdr.slen[2]<<16)
+		+(s900hdr.slen[1]<<8)
+		+s900hdr.slen[0];
+	/* number of samples per part  */
+	samplecountpart=(samplecount+1)/2; /* round up */
+	/* size in bytes in S900 non-compressed sample format */
+	samplesizenoncompr=3*samplecountpart;
+	/* WAV size in bytes */
+	wavsamplesize=2*samplecountpart*2; /* *2 for 16bit per WAV sample word */
+
+	/* allocate non-compressed sample buffer */
+	sbufnoncompr=(u_char *)malloc(samplesizenoncompr);
+	if (sbufnoncompr==NULL){
+		PRINTF_ERR("cannot allocate non-compressed sample buffer\n");
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	/* allocate WAV sample buffer */
+	wavbuf=(u_char *)malloc(wavsamplesize);
+	if (wavbuf==NULL){
+		PRINTF_ERR("cannot allocate WAV buffer\n");
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	/* read non-compressed sample to memory */
+	if (akai_read_file(0,sbufnoncompr,fp,sizeof(struct akai_sample900_s),sizeof(struct akai_sample900_s)+samplesizenoncompr)<0){
+		PRINTF_ERR("cannot read sample\n");
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	/* convert S900 non-compressed sample format into 16bit WAV sample format */
+	akai_sample900noncompr_sample2wav(sbufnoncompr,wavbuf,samplecountpart);
+
+	/* first pass to convert 16bit WAV sample format into S900 compressed sample format */
+	/* Note: first pass of akai_sample900compr_wav2sample() requires WAV sample to be loaded to wavbuf */
+	r=akai_sample900compr_wav2sample(NULL,wavbuf,samplecountpart); /* NULL: first pass */
+	if (r<0){
+		goto akai_sample900_noncompr2compr_exit;
+	}
+	/* S900 compressed sample size in bytes */
+	samplesizecompr=(u_int)r;
+
+	/* create compressed sample file name */
+	/* Note: use RAM name as basis (-> akai_fixramname() not needed afterwards) */
+	akai2ascii_name((u_char *)s900hdr.name,fname,1); /* 1: S900 */
+	strcat(fname,".S9C");
+
+	/* check if destination file already exists */
+	if (akai_find_file(volp,&tmpfile,fname)==0){
+		/* exists */
+		PRINTF_ERR("destination file name \"%s\" already used\n",fname);
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	/* check if enough free blocks */
+	/* required size of compressed file in blocks */
+	i=(sizeof(struct akai_sample900_s)+samplesizecompr+volp->partp->blksize-1)/volp->partp->blksize;
+	if (replaceflag){
+		if (samplesizenoncompr<samplesizecompr){
+			/* subtract size of existing non-compressed file in blocks */
+			i-=(sizeof(struct akai_sample900_s)+samplesizenoncompr+volp->partp->blksize-1)/volp->partp->blksize;
+		}else{
+			i=0;
+		}
+	}
+	if (volp->partp->bfree<i){
+		/* not enough space left */
+		PRINTF_ERR("not enough space left for destination file \"%s\"\n",fname);
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	/* allocate compressed sample buffer */
+	sbufcompr=(u_char *)malloc(samplesizecompr);
+	if (sbufcompr==NULL){
+		PRINTF_ERR("cannot allocate compressed sample buffer\n");
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	/* second pass to convert 16bit WAV sample format into S900 compressed sample format */
+	if (akai_sample900compr_wav2sample(sbufcompr,wavbuf,samplecountpart)<0){ /* sbufcompr!=NULL: second pass */
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	if (replaceflag){
+		/* keep file index */
+		findex=fp->index;
+		/* delete source file */
+		if (akai_delete_file(fp)<0){
+			PRINTF_ERR("cannot overwrite existing file\n");
+			goto akai_sample900_noncompr2compr_exit;
+		}
+	}else{
+		findex=AKAI_CREATE_FILE_NOINDEX;
+	}
+	/* osver for S900 compressed sample file: number of un-compressed floppy blocks */
+	/* Note: without sample header */
+	osver=(samplesizenoncompr+AKAI_FL_BLOCKSIZE-1)/AKAI_FL_BLOCKSIZE; /* round up */
+	if (osver==0){ /* unsuitable osver? */
+		osver=1; /* XXX non zero */
+	}
+	/* create file */
+	/* Note: akai_create_file() will correct osver if necessary */
+	if (akai_create_file(volp,&tmpfile,
+						 sizeof(struct akai_sample900_s)+samplesizecompr,
+						 findex,
+						 fname,
+						 osver,
+						 NULL)<0){
+		PRINTF_ERR("cannot create file\n");
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	/* write sample header */
+	if (akai_write_file(0,(u_char *)&s900hdr,&tmpfile,0,sizeof(struct akai_sample900_s))<0){
+		PRINTF_ERR("cannot write sample header\n");
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	/* write compressed sample */
+	if (akai_write_file(0,sbufcompr,&tmpfile,sizeof(struct akai_sample900_s),sizeof(struct akai_sample900_s)+samplesizecompr)<0){
+		PRINTF_ERR("cannot write sample\n");
+		goto akai_sample900_noncompr2compr_exit;
+	}
+
+	ret=0; /* success */
+
+akai_sample900_noncompr2compr_exit:
+	if (sbufcompr!=NULL){
+		free(sbufcompr);
+	}
+	if (sbufnoncompr!=NULL){
+		free(sbufnoncompr);
+	}
+	if (wavbuf!=NULL){
+		free(wavbuf);
+	}
+	akai_sample900compr_wav2sample(NULL,NULL,0); /* NULL,NULL: free buffers if still allocated */
+	return ret;
+}
+
+
+
+int
+akai_sample2wav(struct file_s *fp,int wavfd,u_int *sizep,char **wavnamep,int what)
+{
+	/* Note: static for multiple calls with different what */
+	static struct akai_sample3000_s s3000hdr;
+	static struct akai_sample900_s *s900hdrp;
+	static u_int hdrsize;
+	static u_int samplecount;
+	static u_int samplecountpart;
+	static u_int samplesize;
+	static u_int samplerate;
+	static u_char *sbuf;
+	static u_int wavsamplesize;
+	static u_char *wavbuf;
+	static int ret;
+	static char wavname[AKAI_NAME_LEN+4+1]; /* name (ASCII), +4 for ".<type>", +1 for '\0' */
+	static u_int nlen;
+	static u_int i;
+
+	if (fp==NULL){
+		return -1;
+	}
+
+	sbuf=NULL; /* no sample so far */
+	wavbuf=NULL; /* no sample so far */
+	ret=-1; /* no success so far */
+
+	if (what&SAMPLE2WAV_CHECK){
+
+		/* file type */
+		if (fp->type==(u_char)AKAI_SAMPLE900_FTYPE){
+			/* S900 sample */
+			hdrsize=sizeof(struct akai_sample900_s);
+		}else if (fp->type==(u_char)AKAI_SAMPLE1000_FTYPE){
+			/* S1000 sample */
+			hdrsize=sizeof(struct akai_sample1000_s);
+		}else if (fp->type==(u_char)AKAI_SAMPLE3000_FTYPE){
+			/* S3000 sample */
+			hdrsize=sizeof(struct akai_sample3000_s);
+		}else{
+			/* unknown or unsupported */
+			return 1; /* no error */
+		}
+
+		/* read header to memory */
+		/* Note: use S3000 header as buffer for S900 header */
+		if (akai_read_file(0,(u_char *)&s3000hdr,fp,0,hdrsize)<0){
+			PRINTF_ERR("cannot read sample\n");
+			goto akai_sample2wav_exit;
+		}
+
+		/* parse header */
+		if (fp->type==(u_char)AKAI_SAMPLE900_FTYPE){
+			/* S900 sample */
+			s900hdrp=(struct akai_sample900_s *)&s3000hdr;
+			/* number of samples */
+			/* XXX should be an even number */
+			samplecount=(s900hdrp->slen[3]<<24)
+				+(s900hdrp->slen[2]<<16)
+				+(s900hdrp->slen[1]<<8)
+				+s900hdrp->slen[0];
+			/* number of samples per part  */
+			samplecountpart=(samplecount+1)/2; /* round up */
+			samplecount=2*samplecountpart; /* XXX correct samplecount */
+			if (fp->osver==0){
+				/* S900 non-compressed sample format */
+				/* size in bytes */
+				samplesize=3*samplecountpart;
+			}else{
+				/* S900 compressed sample format */
+				/* size in bytes */
+				if (fp->size<hdrsize){
+					PRINTF_ERR("invalid sample size\n");
+					goto akai_sample2wav_exit;
+				}
+				samplesize=fp->size-hdrsize;
+			}
+			samplerate=(s900hdrp->srate[1]<<8)
+				+s900hdrp->srate[0];
+		}else{
+			/* S1000/S3000 sample */
+			/* Note: S1000 header is contained within S3000 header */
+			/* number of samples */
+			samplecount=(s3000hdr.s1000.slen[3]<<24)
+				+(s3000hdr.s1000.slen[2]<<16)
+				+(s3000hdr.s1000.slen[1]<<8)
+				+s3000hdr.s1000.slen[0];
+			/* size in bytes */
+			samplesize=samplecount*2; /* *2 for 16bit per sample word */
+			samplecountpart=0;
+			samplerate=(s3000hdr.s1000.srate[1]<<8)
+				+s3000hdr.s1000.srate[0];
+		}
+		/* size in bytes */
+		wavsamplesize=samplecount*2; /* *2 for 16bit per WAV sample word */
+		/* Note: wavsamplesize==0 is allowed here */
+
+#ifdef DEBUG
+		PRINTF_OUT("type:        %15i\n",fp->type);
+		PRINTF_OUT("samplecount: %15u\n",samplecount);
+		PRINTF_OUT("samplesize:  %15u bytes\n",samplesize);
+		PRINTF_OUT("samplerate:  %15u Hz\n",samplerate);
+#endif
+
+		/* check size */
+		if (hdrsize+samplesize>fp->size){
+			PRINTF_ERR("invalid sample size\n");
+			goto akai_sample2wav_exit;
+		}
+
+		if (sizep!=NULL){
+			/* WAV file size */
+			*sizep=WAV_HEAD_SIZE+wavsamplesize;
+#ifndef WAV_AKAIHEAD_DISABLE
+			*sizep+=sizeof(struct wav_chunkhead_s)+hdrsize; /* sample header chunk (see below) */
+#endif
+		}
+
+		/* create WAV name */
+		if ((fp->volp!=NULL)&&(fp->index<fp->volp->fimax)){
+			akai2ascii_name(fp->volp->file[fp->index].name,wavname,fp->volp->type==AKAI_VOL_TYPE_S900);
+			nlen=(u_int)strlen(wavname);
+		}else{
+			nlen=0;
+		}
+		bcopy(".wav",wavname+nlen,5);
+
+		if (wavnamep!=NULL){
+			/* pointer to name (wavname must be static!) */
+			*wavnamep=wavname;
+		}
+	}
+
+	if (what&SAMPLE2WAV_EXPORT){
+
+		if (wavsamplesize>0){
+			/* allocate WAV sample buffer */
+			wavbuf=(u_char *)malloc(wavsamplesize);
+			if (wavbuf==NULL){
+				PRINTF_ERR("cannot allocate WAV buffer\n");
+				goto akai_sample2wav_exit;
+			}
+
+			if (fp->type==(u_char)AKAI_SAMPLE900_FTYPE){ /* S900 sample? */
+				/* allocate sample buffer */
+				sbuf=(u_char *)malloc(samplesize);
+				if (sbuf==NULL){
+					PRINTF_ERR("cannot allocate sample buffer\n");
+					goto akai_sample2wav_exit;
+				}
+			}else{
+				/* Note: no sample format conversion necessary for S1000/S3000 */
+				sbuf=wavbuf;
+			}
+
+			/* read sample to memory */
+			if (akai_read_file(0,sbuf,fp,hdrsize,hdrsize+samplesize)<0){
+				PRINTF_ERR("cannot read sample\n");
+				goto akai_sample2wav_exit;
+			}
+
+			if (fp->type==(u_char)AKAI_SAMPLE900_FTYPE){ /* S900 sample? */
+				if (fp->osver==0){
+					/* S900 non-compressed sample format */
+					/* convert S900 non-compressed sample format into 16bit WAV sample format */
+					akai_sample900noncompr_sample2wav(sbuf,wavbuf,samplecountpart);
+				}else{
+					/* S900 compressed sample format */
+					/* convert S900 compressed sample format into 16bit WAV sample format */
+					i=akai_sample900compr_sample2wav(sbuf,wavbuf,samplesize,wavsamplesize);
+					if (i<wavsamplesize){
+						PRINTF_ERR("warning: incomplete sample data\n");
+						/* zero padding */
+						bzero(wavbuf+i,wavsamplesize-i);
+					}
+				}
+			}
+			/* Note: no sample format conversion necessary for S1000/S3000 */
+		}
+
+		if (what&SAMPLE2WAV_CREATE){
+			/* create WAV file */
+			if ((wavfd=OPEN(wavname,O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+				PERROR("create WAV");
+				goto akai_sample2wav_exit;
+			}
+		}
+
+		/* write WAV header */
+		if (wav_write_head(wavfd,
+						   wavsamplesize,1,samplerate,16, /* 1: mono, 16: 16bit */
+#ifndef WAV_AKAIHEAD_DISABLE
+						   sizeof(struct wav_chunkhead_s)+hdrsize /* sample header chunk (see below) */
+#else
+						   0
+#endif
+						   )<0){
+			PRINTF_ERR("cannot write WAV header\n");
+			goto akai_sample2wav_exit;
+		}
+
+		if (wavsamplesize>0){
+			/* write WAV sample to WAV file */
+			if (WRITE(wavfd,wavbuf,wavsamplesize)!=(int)wavsamplesize){
+				PRINTF_ERR("cannot write WAV samples\n");
+				goto akai_sample2wav_exit;
+			}
+		}
+
+#ifndef WAV_AKAIHEAD_DISABLE
+		{
+			struct wav_chunkhead_s wavchunkhead;
+
+			/* create sample header chunk */
+			if (fp->type==(u_char)AKAI_SAMPLE900_FTYPE){
+				/* S900 sample */
+				bcopy(WAV_CHUNKHEAD_AKAIS900SAMPLEHEADSTR,wavchunkhead.typestr,4);
+			}else if (fp->type==(u_char)AKAI_SAMPLE1000_FTYPE){
+				/* S1000 sample */
+				bcopy(WAV_CHUNKHEAD_AKAIS1000SAMPLEHEADSTR,wavchunkhead.typestr,4);
+			}else{
+				/* S3000 sample */
+				bcopy(WAV_CHUNKHEAD_AKAIS3000SAMPLEHEADSTR,wavchunkhead.typestr,4);
+			}
+			wavchunkhead.csize[0]=0xff&hdrsize;
+			wavchunkhead.csize[1]=0xff&(hdrsize>>8);
+			wavchunkhead.csize[2]=0xff&(hdrsize>>16);
+			wavchunkhead.csize[3]=0xff&(hdrsize>>24);
+			/* write WAV chunk header */
+			if (WRITE(wavfd,(u_char *)&wavchunkhead,sizeof(struct wav_chunkhead_s))!=(int)sizeof(struct wav_chunkhead_s)){
+				PRINTF_ERR("cannot write WAV chunk\n");
+				goto akai_sample2wav_exit;
+			}
+			/* write sample header */
+			/* Note: use S3000 header as buffer for S900 header */
+			/* Note: S1000 header is contained within S3000 header */
+			if (WRITE(wavfd,(u_char *)&s3000hdr,hdrsize)!=(int)hdrsize){
+				PRINTF_ERR("cannot write WAV chunk\n");
+				goto akai_sample2wav_exit;
+			}
+		}
+#endif
+#if 1
+		PRINTF_OUT("sample exported to WAV\n");
+#endif
+	}
+
+	ret=0; /* success */
+
+akai_sample2wav_exit:
+	if (wavbuf!=NULL){
+		free(wavbuf);
+	}
+	if (fp->type==(u_char)AKAI_SAMPLE900_FTYPE){ /* S900 sample? */
+		if (sbuf!=NULL){
+			free(sbuf);
+		}
+	}
+	if (what&SAMPLE2WAV_CREATE){
+		if (wavfd>=0){
+			CLOSE(wavfd);
+		}
+	}
+	return ret;
+}
+
+
+
+int
+akai_wav2sample(int wavfd,char *wavname,struct vol_s *volp,u_int findex,
+				u_int type,int s9cflag,u_int osver,u_char *tagp,
+				u_int *bcountp,int what)
+{
+	/* Note: static for multiple calls with different what */
+	struct file_s tmpfile;
+	struct akai_sample900_s s900hdr;
+	struct akai_sample3000_s s3000hdr;
+	static u_int hdrsize;
+	static u_int samplerate;
+	static u_int samplecount;
+	static u_int samplecountpart;
+	static u_int samplesize;
+	static u_char *sbuf;
+	static u_int wavchnr;
+	static u_int wavbitnr;
+	static int wavmono16flag;
+	static u_int wavsamplesize;
+	static u_int wavsamplecount;
+	static u_int wavch;
+	static u_char *wavbuf16;
+	static u_int wavbuf16size;
+	static u_char *wavbuf;
+	static char *errstrp;
+	static u_int nlen,nlenmax;
+	static char *tname;
+	static char fname[AKAI_NAME_LEN+4+1]; /* name (ASCII), +4 for ".<type>", +1 for '\0' */
+	static char sname[AKAI_NAME_LEN+1]; /* +1 for '\0' */
+	static int r;
+	static u_int bcount;
+#ifndef WAV_AKAIHEAD_DISABLE
+	static u_int extrasize;
+	static int wavakaiheadfound;
+#endif
+	static u_int i;
+	static int ret;
+
+	if (bcountp!=NULL){
+		*bcountp=0; /* no bytes read yet */
+	}
+
+	if (volp==NULL){
+		return -1;
+	}
+
+	/* check WAV name */
+	if (wavname==NULL){
+		return -1;
+	}
+	nlen=(u_int)strlen(wavname);
+	if ((nlen<4)||(strncasecmp(wavname+nlen-4,".wav",4)!=0)){
+		/* not a WAV file */
+		return 1; /* no error */
+	}
+	nlen-=4; /* remove suffix */
+
+	/* sample file type */
+	if (type==AKAI_FTYPE_FREE){ /* invalid file type? */
+		/* derive sample file type from volume type/file osver */
+		if (volp->type==AKAI_VOL_TYPE_S900){
+			/* S900 sample */
+			type=AKAI_SAMPLE900_FTYPE;
+			/* Note: ignore given osver, osver will be overwritten below */
+		}else{
+#if 1
+			if (osver==AKAI_OSVER_S900VOL){
+				/* S900 sample */
+				type=AKAI_SAMPLE900_FTYPE;
+			}else if (osver<=AKAI_OSVER_S1100MAX){
+				/* S1000 sample */
+				type=AKAI_SAMPLE1000_FTYPE;
+			}else{
+				/* S3000 sample */
+				type=AKAI_SAMPLE3000_FTYPE;
+			}
+#else
+			if (volp->type==AKAI_VOL_TYPE_S1000){
+				/* S1000 sample */
+				type=AKAI_SAMPLE1000_FTYPE;
+			}else if ((volp->type==AKAI_VOL_TYPE_S3000)||(volp->type==AKAI_VOL_TYPE_CD3000)){
+				/* S3000 sample */
+				type=AKAI_SAMPLE3000_FTYPE;
+			}else{
+				return -1;
+			}
+#endif
+		}
+	}
+	if (type==AKAI_SAMPLE900_FTYPE){
+		/* S900 sample */
+		hdrsize=sizeof(struct akai_sample900_s);
+		if (s9cflag){
+			/* S900 compressed sample format */
+			tname=".S9C";
+		}else{
+			/* S900 non-compressed sample format */
+			tname=".S9";
+		}
+	}else if (type==AKAI_SAMPLE1000_FTYPE){
+		/* S1000 sample */
+		hdrsize=sizeof(struct akai_sample1000_s);
+		tname=".S1";
+	}else if (type==AKAI_SAMPLE3000_FTYPE){
+		/* S3000 sample */
+		hdrsize=sizeof(struct akai_sample3000_s);
+		tname=".S3";
+	}else{
+		return -1;
+	}
+
+	wavmono16flag=1; /* XXX unknown yet */
+	wavbuf16=NULL; /* not allocated yet */
+	wavbuf=NULL; /* not allocated yet */
+	sbuf=NULL; /* not allocated yet */
+	ret=-1; /* no success so far */
+	bcount=0; /* no bytes read yet */
+
+	if (what&WAV2SAMPLE_OPEN){
+		/* open external WAV file */
+		if ((wavfd=akai_openreadonly_extfile(wavname))<0){
+			PERROR("open WAV");
+			goto akai_wav2sample_exit;
+		}
+	}
+
+	/* read and parse WAV header */
+	if (wav_read_head(wavfd,&bcount,
+							&wavsamplesize,&wavchnr,&samplerate,&wavbitnr,
+#ifndef WAV_AKAIHEAD_DISABLE
+							&extrasize,
+#else
+							NULL,
+#endif
+							&errstrp)<0){
+		if (errstrp!=NULL){
+			PRINTF_ERR("%s\n",errstrp);
+		}
+		/* error, don't know how many bytes read */
+		goto akai_wav2sample_exit;
+	}
+
+	/* check parameters */
+	if ((wavchnr!=1)&&(wavchnr!=2)){
+		PRINTF_ERR("invalid number of channels, must be mono or stereo\n");
+		/* unknown or unsupported */
+		ret=1; /* no error */
+		goto akai_wav2sample_exit;
+	}
+	if ((wavbitnr!=8)&&(wavbitnr!=16)&&(wavbitnr!=24)&&(wavbitnr!=32)){
+		PRINTF_ERR("invalid WAV format, must be 8bit or 16bit or 24bit or 32bit PCM\n");
+		/* unknown or unsupported */
+		ret=1; /* no error */
+		goto akai_wav2sample_exit;
+	}
+	if ((wavchnr==1)&&(wavbitnr==16)){
+		/* WAV file is mono 16bit */
+		wavmono16flag=1;
+	}else{
+		wavmono16flag=0;
+	}
+
+	/* number of samples in WAV file (per channel) */
+	/* Note: can be an odd number */
+	wavsamplecount=wavsamplesize/(wavchnr*(wavbitnr/8));
+#if 0
+	if (wavsamplecount==0){
+		PRINTF_ERR("no samples in WAV file\n");
+		ret=1; /* no error */
+		goto akai_wav2sample_exit;
+	}
+#endif /* else: Note: wavesamplecount==0 is allowed here */
+
+	if (wavsamplecount>0){
+		/* determine number of samples and sample size */
+		if (type==AKAI_SAMPLE900_FTYPE){ /* S900 sample? */
+			/* S900 sample */
+			/* number of samples per part  */
+			samplecountpart=(wavsamplecount+1)/2; /* round up */
+			samplecount=2*samplecountpart; /* samplecount must be an even number */
+			/* set samplesize for S900 non-compressed sample format */
+			/* Note: for S900 compressed sample format, samplesize will be overwritten below */
+			/* size in bytes */
+			samplesize=3*samplecountpart;
+		}else{
+			/* S1000/S3000 sample */
+			samplecountpart=0;
+			samplecount=wavsamplecount;
+			/* size in bytes */
+			samplesize=samplecount*2; /* *2 for 16bit per sample word */
+		}
+
+		/* allocate WAV 16bit sample buffer */
+		wavbuf16size=2*samplecount; /* *2 for 16bit per sample word in wavbuf16 */
+		if (wavmono16flag&&(wavbuf16size<wavsamplesize)){
+			/* Note: need at least wavsamplesize for wavbuf==wavbuf16 below */
+			wavbuf16size=wavsamplesize;
+		}
+		wavbuf16=(u_char *)malloc(wavbuf16size);
+		if (wavbuf16==NULL){
+			PRINTF_ERR("cannot allocate WAV 16bit buffer\n");
+			goto akai_wav2sample_exit;
+		}
+		if (type!=AKAI_SAMPLE900_FTYPE){ /* S1000/S3000 sample? */
+			/* use wavbuf16 as sample buffer */
+			sbuf=wavbuf16;
+		}
+		/* Note: for S900 sample, sbuf will be allocated below */
+
+		/* WAV sample buffer */
+		if (wavmono16flag){ /* WAV file is mono 16bit? */
+			/* use wavbuf16 as WAV sample buffer */
+			wavbuf=wavbuf16;
+		}else{
+			/* allocate WAV sample buffer */
+			wavbuf=(u_char *)malloc(wavsamplesize);
+			if (wavbuf==NULL){
+				PRINTF_ERR("cannot allocate WAV buffer\n");
+				goto akai_wav2sample_exit;
+			}
+		}
+
+		/* read WAV sample to memory */
+		if (READ(wavfd,wavbuf,wavsamplesize)!=(int)wavsamplesize){
+			PRINTF_ERR("cannot read sample\n");
+			goto akai_wav2sample_exit;
+		}
+		bcount+=wavsamplesize;
+
+		/* zero padding if necessary */
+		/* Note: must be after READ to wavbuf for case that wavbuf==wavbuf16 */
+		if (samplecount>wavsamplecount){
+			/* 16bit sample word */
+			wavbuf16[wavsamplecount*2+1]=0x00;
+			wavbuf16[wavsamplecount*2+0]=0x00;
+		}
+	}else{
+		samplecountpart=0;
+		samplecount=0;
+		samplesize=0;
+	}
+
+	/* correct osver if necessary */
+	if (type==AKAI_SAMPLE900_FTYPE){
+		/* S900 sample */
+		/* Note: here, samplesize==non-compressed sample size in bytes */
+		if (s9cflag){
+			/* S900 compressed sample format */
+			/* set osver=number of un-compressed floppy blocks */
+			/* Note: without sample header */
+			osver=(samplesize+AKAI_FL_BLOCKSIZE-1)/AKAI_FL_BLOCKSIZE; /* round up */
+			if (osver==0){ /* unsuitable osver? */
+				osver=1; /* XXX non zero */
+			}
+		}else{
+			/* S900 non-compressed sample format */
+			osver=0;
+		}
+	}else if (type==AKAI_SAMPLE1000_FTYPE){
+		/* S1000 sample */
+		if ((osver==AKAI_OSVER_S900VOL)||(osver>AKAI_OSVER_S1100MAX)){
+			osver=AKAI_OSVER_S1000MAX; /* XXX */
+		}
+	}else{
+		/* S3000 sample */
+		if ((osver==AKAI_OSVER_S900VOL)||(osver>AKAI_OSVER_S3000MAX)){
+			osver=AKAI_OSVER_S3000MAX; /* XXX */
+		}
+	}
+
+	/* sample name */
+	if ((type==AKAI_SAMPLE900_FTYPE)||(volp->type==AKAI_VOL_TYPE_S900)){ /* S900 sample or S900 volume? */
+		nlenmax=AKAI_NAME_LEN_S900;
+	}else{
+		nlenmax=AKAI_NAME_LEN;
+	}
+	if (wavchnr==1){
+		/* mono */
+		if (nlen>nlenmax){
+			nlen=nlenmax;
+		}
+		bcopy(wavname,sname,nlen);
+		sname[nlen]='\0';
+	}else{
+		/* stereo */
+		if (nlen>nlenmax-2){
+			nlen=nlenmax-2;
+		}
+		bcopy(wavname,sname,nlen);
+		for (i=nlen;i<nlenmax-2;i++){
+			sname[i]=' ';
+		}
+		sname[i++]='-';
+		sname[i++]='L'; /* left channel first */
+		sname[i]='\0';
+	}
+	sprintf(fname,"%s%s",sname,tname);
+	/* Note: if stereo, channel letter in sname,fname will be updated below */
+
+	/* sample header */
+#ifndef WAV_AKAIHEAD_DISABLE
+	/* check for sample header chunk in WAV file */
+	{
+		u_int wavakaiheadsearchtype;
+		int wavakaiheadtype;
+		u_int wavakaiheadsize;
+		u_int bc;
+
+		/* matching type */
+		if (type==AKAI_SAMPLE900_FTYPE){
+			wavakaiheadsearchtype=WAV_AKAIHEADTYPE_SAMPLE900;
+		}else if (type==AKAI_SAMPLE1000_FTYPE){
+			wavakaiheadsearchtype=WAV_AKAIHEADTYPE_SAMPLE1000;
+		}else{
+			wavakaiheadsearchtype=WAV_AKAIHEADTYPE_SAMPLE3000;
+		}
+
+		wavakaiheadtype=wav_find_akaihead(wavfd,&bc,&wavakaiheadsize,extrasize,wavakaiheadsearchtype);
+		if (wavakaiheadtype<0){
+			goto akai_wav2sample_exit;
+		}
+		bcount+=bc;
+
+		if ((wavakaiheadtype==(int)wavakaiheadsearchtype)&&(wavakaiheadsize==hdrsize)){
+			/* found matching sample header chunk */
+			wavakaiheadfound=1;
+		}else{
+			wavakaiheadfound=0;
+		}
+	}
+#endif
+	if (type==AKAI_SAMPLE900_FTYPE){
+		/* S900 sample */
+#ifndef WAV_AKAIHEAD_DISABLE
+		if (wavakaiheadfound){
+			/* read S900 sample header */
+			if (READ(wavfd,(u_char *)&s900hdr,hdrsize)!=(int)hdrsize){
+				PRINTF_ERR("cannot read sample header\n");
+				goto akai_wav2sample_exit;
+			}
+			bcount+=hdrsize;
+#if 1
+			PRINTF_OUT("S900 sample header imported from WAV\n");
+#endif
+		}else
+#endif
+		{
+			/* create S900 sample header */
+			bzero(&s900hdr,sizeof(struct akai_sample900_s));
+
+			s900hdr.srate[1]=0xff&(samplerate>>8);
+			s900hdr.srate[0]=0xff&samplerate;
+
+			s900hdr.npitch[1]=0xff&(SAMPLE900_NPITCH_DEF>>8); /* XXX */
+			s900hdr.npitch[0]=0xff&SAMPLE900_NPITCH_DEF; /* XXX */
+
+			s900hdr.pmode=SAMPLE900_PMODE_ONESHOT; /* XXX */
+
+			/* Note: use wavsamplecount for end */
+			s900hdr.end[3]=0xff&(wavsamplecount>>24);
+			s900hdr.end[2]=0xff&(wavsamplecount>>16);
+			s900hdr.end[1]=0xff&(wavsamplecount>>8);
+			s900hdr.end[0]=0xff&wavsamplecount;
+
+			/* Note: use wavsamplecount for llen */
+			s900hdr.llen[3]=0xff&(wavsamplecount>>24);
+			s900hdr.llen[2]=0xff&(wavsamplecount>>16);
+			s900hdr.llen[1]=0xff&(wavsamplecount>>8);
+			s900hdr.llen[0]=0xff&wavsamplecount;
+
+			s900hdr.dir=SAMPLE900_DIR_NORM; /* XXX */
+		}
+
+		/* set correct slen */
+		s900hdr.slen[3]=0xff&(samplecount>>24);
+		s900hdr.slen[2]=0xff&(samplecount>>16);
+		s900hdr.slen[1]=0xff&(samplecount>>8);
+		s900hdr.slen[0]=0xff&samplecount;
+	}else{
+		/* S1000/S3000 sample */
+#ifndef WAV_AKAIHEAD_DISABLE
+		if (wavakaiheadfound){
+			/* read S1000/S3000 sample header */
+			/* Note: S1000 header is contained within S3000 header */
+			if (READ(wavfd,(u_char *)&s3000hdr,hdrsize)!=(int)hdrsize){
+				PRINTF_ERR("cannot read sample header\n");
+				goto akai_wav2sample_exit;
+			}
+			bcount+=hdrsize;
+#if 1
+			if (type==AKAI_SAMPLE1000_FTYPE){
+				PRINTF_OUT("S1000 sample header imported from WAV\n");
+			}else{
+				PRINTF_OUT("S3000 sample header imported from WAV\n");
+			}
+#endif
+		}else
+#endif
+		{
+			/* create S3000 sample header */
+			/* Note: S1000 header is contained within S3000 header */
+			bzero(&s3000hdr,sizeof(struct akai_sample3000_s));
+
+			s3000hdr.s1000.blockid=SAMPLE1000_BLOCKID;
+			s3000hdr.s1000.bandw=SAMPLE1000_BANDW_20KHZ; /* XXX */
+			s3000hdr.s1000.rkey=60; /* XXX */
+			s3000hdr.s1000.dummy1=0x80; /* XXX */
+
+			/* Note: use wavsamplecount-1 for end */
+			s3000hdr.s1000.end[3]=0xff&((wavsamplecount-1)>>24);
+			s3000hdr.s1000.end[2]=0xff&((wavsamplecount-1)>>16);
+			s3000hdr.s1000.end[1]=0xff&((wavsamplecount-1)>>8);
+			s3000hdr.s1000.end[0]=0xff&(wavsamplecount-1);
+
+			s3000hdr.s1000.stpaira[1]=0xff&(AKAI_SAMPLE1000_STPAIRA_NONE>>8);
+			s3000hdr.s1000.stpaira[0]=0xff&AKAI_SAMPLE1000_STPAIRA_NONE;
+
+			s3000hdr.s1000.srate[1]=0xff&(samplerate>>8);
+			s3000hdr.s1000.srate[0]=0xff&samplerate;
+		}
+
+		/* set correct slen */
+		s3000hdr.s1000.slen[3]=0xff&(samplecount>>24);
+		s3000hdr.s1000.slen[2]=0xff&(samplecount>>16);
+		s3000hdr.s1000.slen[1]=0xff&(samplecount>>8);
+		s3000hdr.s1000.slen[0]=0xff&samplecount;
+	}
+	/* Note: RAM name of sample in sample header will be set below */
+
+	/* process WAV channels */
+	wavch=0;
+	for (;;){
+		if (wavsamplecount>0){
+			if (!wavmono16flag){ /* WAV file is not mono 16bit? */
+				/* de-interleave WAV channels and convert sample format */
+				if (wavbitnr==8){
+					/* convert 8bit WAV sample format into 16bit WAV sample format */
+					for (i=0;i<wavsamplecount;i++){
+						wavbuf16[i*2+1]=0x80^wavbuf[wavchnr*i+wavch]; /* toggle sign bit */
+						wavbuf16[i*2+0]=0x00;
+					}
+				}else if (wavbitnr==16){
+					/* keep 16bit WAV sample format */
+					for (i=0;i<wavsamplecount;i++){
+						wavbuf16[i*2+0]=wavbuf[(wavchnr*i+wavch)*2+0];
+						wavbuf16[i*2+1]=wavbuf[(wavchnr*i+wavch)*2+1];
+					}
+				}else if (wavbitnr==24){
+					/* convert 24bit WAV sample format into 16bit WAV sample format */
+					for (i=0;i<wavsamplecount;i++){
+						/* Note: copy upper 16 bits, discard lower 8 bits */
+						wavbuf16[i*2+0]=wavbuf[(wavchnr*i+wavch)*3+1];
+						wavbuf16[i*2+1]=wavbuf[(wavchnr*i+wavch)*3+2];
+					}
+				}else if (wavbitnr==32){
+					/* convert 32bit WAV sample format into 16bit WAV sample format */
+					for (i=0;i<wavsamplecount;i++){
+						/* Note: copy upper 16 bits, discard lower 16 bits */
+						wavbuf16[i*2+0]=wavbuf[(wavchnr*i+wavch)*4+2];
+						wavbuf16[i*2+1]=wavbuf[(wavchnr*i+wavch)*4+3];
+					}
+				}
+			} /* Note: else: wavbuf==wavbuf16 */
+
+			if ((type==AKAI_SAMPLE900_FTYPE)&&s9cflag){ /* S900 compressed sample format? */
+				/* determine sample size */
+				/* first pass to convert 16bit WAV sample format into S900 compressed sample format */
+				/* Note: first pass of akai_sample900compr_wav2sample() requires 16bit WAV sample to be loaded to wavbuf16 */
+				r=akai_sample900compr_wav2sample(NULL,wavbuf16,samplecountpart); /* NULL: first pass */
+				if (r<0){
+					goto akai_wav2sample_exit;
+				}
+				/* size in bytes */
+				samplesize=(u_int)r;
+			}
+			/* check sample size */
+			if (hdrsize+samplesize>AKAI_FILE_SIZEMAX){
+				PRINTF_ERR("WAV file is too large\n");
+				/* unknown or unsupported */
+				ret=1; /* no error */
+				goto akai_wav2sample_exit;
+			}
+			if (type==AKAI_SAMPLE900_FTYPE){ /* S900 sample? */
+				/* allocate sample buffer */
+				sbuf=(u_char *)malloc(samplesize);
+				if (sbuf==NULL){
+					PRINTF_ERR("cannot allocate sample buffer\n");
+					goto akai_wav2sample_exit;
+				}
+			}
+		}
+
+		if (wavch==1){ /* right channel? */
+			/* update sample name */
+			i=nlenmax-1;
+			sname[i]='R'; /* right channel */
+			fname[i]=sname[i];
+		}
+
+#ifdef WAV2SAMPLE_OVERWRITE
+		if ((findex==AKAI_CREATE_FILE_NOINDEX)
+			/* check if destination file already exists */
+			&&(akai_find_file(volp,&tmpfile,fname)==0)){
+			/* exists */
+			if (what&WAV2SAMPLE_OVERWRITE){
+				/* delete file */
+				if (akai_delete_file(&tmpfile)<0){
+					PRINTF_ERR("cannot overwrite existing file\n");
+					goto akai_wav2sample_exit;
+				}
+			}else{
+				PRINTF_ERR("file name already used\n");
+				goto akai_wav2sample_exit;
+			}
+		}
+#endif
+
+		/* create file */
+		/* Note: akai_create_file() will correct osver if necessary */
+		if (akai_create_file(volp,&tmpfile,
+							 hdrsize+samplesize,
+							 findex,
+							 fname,
+							 osver,
+							 tagp)<0){
+			PRINTF_ERR("cannot create file\n");
+			goto akai_wav2sample_exit;
+		}
+
+		if (type==AKAI_SAMPLE900_FTYPE){
+			/* S900 sample */
+
+			/* set RAM name of sample in sample header */
+			/* Note: akai_fixramname() not needed afterwards */
+			ascii2akai_name(sname,(u_char *)s900hdr.name,1); /* 1: S900 */
+
+			/* write sample header */
+			if (akai_write_file(0,(u_char *)&s900hdr,&tmpfile,0,hdrsize)<0){
+				PRINTF_ERR("cannot write sample header\n");
+				goto akai_wav2sample_exit;
+			}
+
+			if (wavsamplecount>0){
+				if (s9cflag){
+					/* second pass to convert 16bit WAV sample format into S900 compressed sample format */
+					if (akai_sample900compr_wav2sample(sbuf,wavbuf16,samplecountpart)<0){ /* sbuf!=NULL: second pass */
+						goto akai_wav2sample_exit;
+					}
+				}else{
+					/* convert 16bit WAV sample format into S900 non-compressed sample format */
+					akai_sample900noncompr_wav2sample(sbuf,wavbuf16,samplecountpart);
+				}
+			}
+		}else{
+			/* S1000/S3000 sample */
+
+			/* set RAM name of sample in sample header */
+			/* Note: akai_fixramname() not needed afterwards */
+			ascii2akai_name(sname,s3000hdr.s1000.name,0); /* 0: not S900 */
+
+			/* write sample header */
+			if (akai_write_file(0,(u_char *)&s3000hdr,&tmpfile,0,hdrsize)<0){
+				PRINTF_ERR("cannot write sample header\n");
+				goto akai_wav2sample_exit;
+			}
+
+			/* Note: sbuf==wavbuf16 for S1000/S3000 sample */
+		}
+
+		if (wavsamplecount>0){
+			/* write sample */
+			if (akai_write_file(0,sbuf,&tmpfile,hdrsize,hdrsize+samplesize)<0){
+				PRINTF_ERR("cannot write sample\n");
+				goto akai_wav2sample_exit;
+			}
+		}
+
+		if (wavchnr==1){ /* mono? */
+#if 1
+			PRINTF_OUT("sample imported from WAV\n");
+#endif
+			break; /* done */
+		} /* else: stereo */
+#if 1
+		PRINTF_OUT("%s sample imported from WAV\n",(wavch==0)?"left":"right");
+#endif
+
+		/* next WAV channel */
+		wavch++;
+		if (wavch>=wavchnr){
+			break; /* done */
+		}
+		if (findex!=AKAI_CREATE_FILE_NOINDEX){
+			findex++; /* XXX next file index */
+		}
+		if (type==AKAI_SAMPLE900_FTYPE){ /* S900 sample? */
+			if (sbuf!=NULL){
+				free(sbuf);
+				sbuf=NULL;
+			}
+			if (s9cflag){
+				akai_sample900compr_wav2sample(NULL,NULL,0); /* NULL,NULL: free buffers if still allocated */
+			}
+		}
+	}
+
+	ret=0; /* success */
+
+akai_wav2sample_exit:
+	if (wavbuf16!=NULL){
+		free(wavbuf16);
+	}
+	if ((!wavmono16flag)&&(wavbuf!=NULL)){
+		free(wavbuf);
+	}
+	if (type==AKAI_SAMPLE900_FTYPE){ /* S900 sample? */
+		if (sbuf!=NULL){
+			free(sbuf);
+		}
+		if (s9cflag){
+			akai_sample900compr_wav2sample(NULL,NULL,0); /* NULL,NULL: free buffers if still allocated */
+		}
+	}
+	if (what&WAV2SAMPLE_OPEN){
+		if (wavfd>=0){
+			CLOSE(wavfd);
+		}
+	}
+	if (bcountp!=NULL){
+		*bcountp=bcount;
+	}
+	return ret;
+}
+
+
+
+/* EOF */
diff --git a/third_party/akaiutil/akaiutil_file.h b/third_party/akaiutil/akaiutil_file.h
new file mode 100755
index 0000000..5ceae43
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_file.h
@@ -0,0 +1,563 @@
+#ifndef __AKAIUTIL_FILE_H
+#define __AKAIUTIL_FILE_H
+/*
+* Copyright (C) 2010,2012,2018,2019,2020 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+#include "akaiutil.h"
+
+
+
+/* AKAI files */
+
+/* Note: all data types are little endian */
+
+
+
+/* AKAI file type ranges */
+#define AKAI_S900_FTYPE_MIN		'A' /* min. file type for S900 */
+#define AKAI_S900_FTYPE_MAX		'Z' /* max. file type for S900 */
+#define AKAI_S1000_FTYPE_MIN	'a' /* min. file type for S1000 */
+#define AKAI_S1000_FTYPE_MAX	'z' /* max. file type for S1000 */
+#define AKAI_S3000_FTYPE_MIN	('a'+0x80) /* min. file type for S3000 */
+#define AKAI_S3000_FTYPE_MAX	('z'+0x80) /* max. file type for S3000 */
+/* Note: exception: AKAI_CDSETUP3000_FTYPE=='T' is within range of file types for S900 */
+
+
+
+/* AKAI S900 sample header */
+struct akai_sample900_s{
+	char name[AKAI_NAME_LEN_S900]; /* sample name (in RAM) */
+	u_char dummy1[6];   /* XXX 0x00 */
+	u_char slen[4];     /* number of samples */
+	u_char srate[2];    /* sample rate in Hz */
+#define SAMPLE900_NPITCH_DEF		(60*16) /* default */
+	u_char npitch[2];   /* nominal pitch in 1/16 semitones */
+	u_char loud[2];     /* loudness offset (signed) */
+#define SAMPLE900_PMODE_ONESHOT		'O'
+#define SAMPLE900_PMODE_LOOP		'L'
+#define SAMPLE900_PMODE_ALTLOOP		'A'
+	u_char pmode;       /* playback mode */
+	u_char dummy2;      /* XXX */
+	u_char end[4];      /* end marker */
+	u_char start[4];    /* start marker */
+	u_char llen[4];     /* loop length */
+	u_char dmadesa[2];  /* address of DMA descriptor list (updated by sampler) */
+#define SAMPLE900_TYPE_NORM		0x00 /* normal */
+#define SAMPLE900_TYPE_VELXF	0xff /* velocity crossfade */
+	u_char type;        /* sample type */
+#define SAMPLE900_DIR_NORM		'N'
+#define SAMPLE900_DIR_REV		'R'
+	u_char dir;         /* time direction */
+	u_char dummy3[10];  /* XXX */
+	u_char locat[4];    /* absolute address (updated by sampler) */
+	u_char dummy4[2];  /* XXX */
+}; /* Note: should be 0x003c Bytes */
+/* Note: header is followed by sample data (in non-compressed or compressed sample format) */
+
+/* S900 compressed sample format */
+#define SAMPLE900COMPR_GROUP_SAMPNUM		10 /* number of samples per group */
+#define SAMPLE900COMPR_UPBITNUM_NEGCODE_OFF	16 /* offset between bit number for upabsval and -code */
+#define SAMPLE900COMPR_UPBITNUM_MAX			12 /* max. bit number to be used for upabsval */
+#define SAMPLE900COMPR_INTERVALSIZ			(1<<SAMPLE900COMPR_UPBITNUM_MAX)  /* interval size for max. bit number */
+#define SAMPLE900COMPR_BITMASK				(SAMPLE900COMPR_INTERVALSIZ-1)  /* bit mask for interval */
+#define SAMPLE900COMPR_INTERVALSIZ2			(SAMPLE900COMPR_INTERVALSIZ>>1) /* half interval size */
+
+#define AKAI_SAMPLE900_FTYPE	'S' /* file type */
+
+
+
+/* AKAI S900 program header */
+struct akai_program900_s{
+	char name[AKAI_NAME_LEN_S900]; /* program name (in RAM) */
+	u_char dummy1[6];   /* XXX 0x00 */
+	u_char dummy2[2];   /* XXX */
+#define PROGRAM900_KGA_NONE		0x0000 /* value for none */
+	u_char kg1a[2];     /* address of keygroup 1 (updated by sampler) */
+	u_char dummy3;      /* XXX */
+	u_char kgxf;        /* keygroup (positional) crossfade enable */
+	u_char dummy4;      /* XXX */
+	u_char kgnum;       /* number of keygroups */
+	u_char dummy5[14];  /* XXX */
+}; /* Note: should be 0x0026 Bytes */
+/* Note: header is followed by keygroups */
+
+/* AKAI S900 program: keygroup */
+struct akai_program900kg_s{
+	u_char keyhi;       /* high MIDI key */
+	u_char keylo;       /* low MIDI key */
+#define PROGRAM900KG_VELSWTH_NOSOFT	0   /* value for no soft sample */
+#define PROGRAM900KG_VELSWTH_NOLOUD	128 /* value for no loud sample */
+	u_char velswth;     /* velocity switch threshold */
+	u_char dummy1[15];  /* XXX */
+#define PROGRAM900KG_FLAGS_PCONST	0x01 /* constant pitch enable */
+#define PROGRAM900KG_FLAGS_VELXF	0x02 /* velocity crossfade enable */
+#define PROGRAM900KG_FLAGS_ONESHOT	0x08 /* one-shot trigger mode enable */
+	u_char flags;       /* flags */
+#define PROGRAM900KG_OUTCH1_LEFT	0x08 /* code for LEFT */
+#define PROGRAM900KG_OUTCH1_RIGHT	0x09 /* code for RIGHT */
+#define PROGRAM900KG_OUTCH1_ANY		0xff /* code for ANY */
+	u_char outch1;      /* audio output channel: channel number-1 or code */
+	u_char midichoff;   /* MIDI channel offset */
+	u_char dummy2[3];   /* XXX */
+	u_char sname1[AKAI_NAME_LEN_S900]; /* sample name (in RAM) for sample 1 ("soft") */
+	u_char dummy3[4];   /* XXX */
+	u_char velxfv50;    /* if velocity crossfade: velocity value for 50% */
+	u_char dummy4;      /* XXX */
+#define PROGRAM900KG_SHDRA_NONE		0x0000 /* value for none */
+	u_char shdra1[2];	/* address of sample header for sample 1 (updated by sampler) */
+	u_char tune1[2];    /* tuning offset (transpose) in 1/16 semitones (signed) for sample 1 */
+	u_char filter1;     /* filter for sample 1 */
+	u_char loud1;       /* loudness offset (signed) for sample 1 */
+	u_char sname2[AKAI_NAME_LEN_S900]; /* sample name (in RAM) for sample 2 ("loud") */
+	u_char dummy5[6];   /* XXX */
+	u_char shdra2[2];	/* address of sample header for sample 2 (updated by sampler) */
+	u_char tune2[2];    /* tuning offset in 1/16 semitones (signed) for sample 2 */
+	u_char filter2;     /* filter for sample 2 */
+	u_char loud2;       /* loudness offset (signed) for sample 2 */
+	u_char kgnexta[2];  /* address of next keygroup (updated by sampler) */
+}; /* Note: should be 0x0046 Bytes */
+
+#define AKAI_PROGRAM900_FTYPE	'P' /* file type */
+
+
+
+/* AKAI S900/S950 drum settings descriptor */
+struct akai_drum900des_s{
+	u_char inpnr1;       /* input number-1 */
+	u_char midich1;      /* MIDI channel-1 */
+	u_char midinote;     /* MIDI note */
+	u_char gain;         /* gain */
+	u_char ask90_trig;   /* if ASK90: trigger threshold */
+	                     /* if ME35T: (ignored) */
+	u_char dummy1[3];    /* XXX */
+#define DRUM900DES_ITYPE_ASK90		0x00 /* interface type: ASK90 */
+#define DRUM900DES_ITYPE_ME35T		0xff /* interface type: ME35T */
+	u_char itype;        /* interface type */
+	u_char me35t_trig;   /* if ASK90: (ignored) */
+	                     /* if ME35T: trigger threshold */
+	u_char me35t_vcurv1; /* if ASK90: (ignored) */
+	                     /* if ME35T: "V-curve"-1 */
+	u_char dummy2;       /* XXX */
+	u_char captt4[2];    /* 4* capture time in msec */
+	u_char ontime4[2];   /* 4* on-time in msec */
+	u_char recovt4[2];   /* 4* recovery time in msec */
+	u_char dummy3[8];
+	u_char ask90_resba[2]; /* if ASK90: ASK90 base address for CH RESET */
+	                       /* if ME35T: (ignored) */
+	u_char ask90_adcla[2]; /* if ASK90: ASK90 address for ADC latch */
+	                       /* if ME35T: (ignored) */
+}; /* Note: should be 0x001e Bytes */
+
+/* AKAI S900/S950 drum settings file */
+struct akai_drum900_s{
+	u_char ask90enab;  /* if ASK90: ASK90 enable */
+	                   /* if ME35T: (ignored) */
+	u_char ask90sens;  /* if ASK90: ASK90 sensitivity */
+	                   /* if ME35T: (ignored) */
+	u_char dummy1[20]; /* XXX 0x00 ... 0x00 */
+#define DRUM900_INPUTNUM		8 /* number of drum trigger inputs */
+	struct akai_drum900des_s ddes[DRUM900_INPUTNUM]; /* drum setting descriptors */
+}; /* Note: should be 0x0106 Bytes */
+
+#define AKAI_DRUM900_FTYPE		'D' /* file type */
+#define AKAI_DRUM900_FNAME		"DRUM SET  " /* default file name */
+
+
+
+/* AKAI S900 overall settings file */
+struct akai_ovs900_s{
+	char progname[AKAI_NAME_LEN_S900]; /* selected program name */
+	u_char dummy1[6];       /* XXX 0x20 ... 0x20 */
+	u_char dummy2[4];       /* XXX */
+	u_char testmidich[2];   /* test MIDI channel */
+	u_char testmidikey[2];  /* test MIDI key */
+	u_char testmidivel[2];  /* test MIDI velocity */
+	u_char dummy3; /* XXX */
+#define OVS900_BMIDICH1MASK		0x7f /* bit mask for basic MIDI channel-1 */
+#define OVS900_OMNIMASK			0x80 /* bit mask for OMNI flag */
+	u_char bmidich1omni;    /* basic MIDI channel-1 | OMNI flag */
+	u_char loudness;        /* loudness enable */
+#define OVS900_CTRLPORT_MIDI	0x01 /* control port: MIDI */
+#define OVS900_CTRLPORT_RS232	0x02 /* control port: RS232 */
+	u_char ctrlport;        /* control port */
+	u_char progchange;      /* program change enable */
+	u_char dummy4[4];       /* XXX */
+	u_char pwheelrange;     /* pitch wheel range */
+	u_char rs232brate10[2]; /* RS232 baudrate/10 */
+	u_char dummy5[2];       /* XXX */
+}; /* Note: should be 0x0028 Bytes */
+
+#define AKAI_OVS900_FTYPE		'O' /* file type */
+#define AKAI_OVS900_FNAME		"OVERALL SE" /* default file name */
+
+
+
+/* AKAI S900 fixup file */
+#define AKAI_FIXUP900_FTYPE		'F' /* file type */
+
+/* AKAI S900 memory image file */
+#define AKAI_MEMIMG900_FTYPE	'M' /* file type */
+
+
+
+/* AKAI S1000 empty file name */
+#define AKAI_EMPTY1000_FNAME	"VVVVVVVVVVVV" /* S1000 empty file name */
+
+
+
+/* AKAI S1000 generic header */
+struct akai_genfilehdr_s{
+	u_char blockid;   /* block ID */
+	u_char dummy1[2]; /* XXX */
+	u_char name[AKAI_NAME_LEN]; /* file name (in RAM) */
+}; /* Note: should be 0x000f Bytes */
+
+
+
+/* AKAI S1000 sample loop parameters */
+struct akai_sample1000loop_s{
+	u_char at[4];     /* loop at marker */
+	u_char flen[2];   /* loop fine length in 1/65536 sample */
+	u_char len[4];    /* loop length in samples */
+#define SAMPLE1000LOOP_TIME_NOLOOP	0    /* value for NOLOOP */
+#define SAMPLE1000LOOP_TIME_HOLD	9999 /* value for HOLD */
+	u_char time[2];   /* loop time in msec */
+};
+
+/* AKAI S1000 sample header */
+struct akai_sample1000_s{
+#define SAMPLE1000_BLOCKID		0x03
+	u_char blockid;      /* block ID */
+#define SAMPLE1000_BANDW_10KHZ		0x00
+#define SAMPLE1000_BANDW_20KHZ		0x01
+	u_char bandw;       /* bandwidth select */
+	u_char rkey;        /* MIDI root key (typ. 0x3c) */
+	u_char name[AKAI_NAME_LEN]; /* sample name (in RAM) */
+	u_char dummy1;      /* XXX 0x80 */
+	u_char lnum;        /* number of loops */
+	u_char lfirst;      /* first active loop-1 */
+	u_char dummy2;      /* XXX 0x00 */
+#define SAMPLE1000_PMODE_LOOP		0x00
+#define SAMPLE1000_PMODE_LOOPNOTREL	0x01
+#define SAMPLE1000_PMODE_NOLOOP		0x02
+#define SAMPLE1000_PMODE_TOEND		0x03
+	u_char pmode;       /* playback mode */
+	u_char ctune;       /* cents tune (signed) */
+	u_char stune;       /* semitone tune (signed) */
+	u_char locat[4];    /* absolute address (updated by sampler) */
+	u_char slen[4];     /* number of samples */
+	u_char start[4];    /* start marker */
+	u_char end[4];      /* end marker */
+#define AKAI_SAMPLE1000_LOOPNUM	8
+	struct akai_sample1000loop_s loop[AKAI_SAMPLE1000_LOOPNUM];
+	u_char dummy3[2];   /* XXX 0x00 0x00 */
+#define AKAI_SAMPLE1000_STPAIRA_NONE	0xffff /* value for none */
+	u_char stpaira[2];  /* address of sample header of partner in stereo pair (updated by sampler) */
+	u_char srate[2];    /* sample rate in Hz */
+	u_char hltoff;      /* HOLD loop tune offset */
+	u_char dummy4[9];   /* XXX 0x00 ... 0x00 */
+}; /* Note: should be 0x0096 Bytes */
+/* Note: header is followed by sample data */
+
+#define AKAI_SAMPLE1000_FTYPE	's' /* file type */
+
+
+
+/* AKAI S3000 sample header */
+struct akai_sample3000_s{
+#define SAMPLE3000_BLOCKID		SAMPLE1000_BLOCKID
+	struct akai_sample1000_s s1000;
+	u_char dummy1[42];  /* XXX 0x00 ... 0x00 */
+}; /* Note: should be 0x00c0 Bytes */
+/* Note: header is followed by sample data */
+
+/* address multiplicand */
+#define SAMPLE3000_STPAIRA_MULT	0x10
+
+#define AKAI_SAMPLE3000_FTYPE	('s'+0x80) /* file type */
+
+
+
+/* AKAI CD3000 CD-ROM sample parameters file */
+/* Note: contains S3000 sample header */
+#define AKAI_CDSAMPLE3000_FTYPE	('h'+0x80) /* file type */
+
+
+
+/* AKAI S1000 program header */
+struct akai_program1000_s{
+#define PROGRAM1000_BLOCKID		0x01
+	u_char blockid;      /* block ID */
+#define PROGRAM1000_KGA_NONE	0x0000 /* value for none */
+	u_char kg1a[2];      /* address of keygroup 1 (updated by sampler) */
+	u_char name[AKAI_NAME_LEN]; /* program name (in RAM) */
+	u_char dummy1;       /* XXX */
+#define PROGRAM1000_MIDICH1_OMNI	0xff /* code for OMNI */
+	u_char midich1;      /* MIDI channel number-1 or code */
+	u_char dummy2[2];    /* XXX */
+	u_char keylo;        /* low MIDI key */
+	u_char keyhi;        /* high MIDI key */
+	u_char oct;          /* octave offset (signed) */
+#define PROGRAM1000_AUXCH1_OFF		0xff /* code for OFF */
+	u_char auxch1;        /* aux output channel number-1 or code */
+	u_char dummy3[18];   /* XXX */
+	u_char kgxf;         /* keygroup crossfade enable */
+	u_char kgnum;        /* number of keygroups */
+	u_char dummy4[107];  /* XXX */
+}; /* Note: should be 0x0096 Bytes */
+/* Note: header is followed by keygroups */
+
+/* AKAI S1000 program keygroup: velocity zone */
+struct akai_program1000kgvelzone_s{
+	u_char sname[AKAI_NAME_LEN]; /* sample name (in RAM) */
+	u_char vello;       /* low MIDI velocity */
+	u_char velhi;       /* high MIDI velocity */
+	u_char ctune;       /* cents tune offset (signed) */
+	u_char stune;       /* semitone tune offset (signed) */
+	u_char loud;        /* loudness offset (signed) */
+	u_char filter;      /* filter offset (signed) */
+	u_char pan;         /* pan offset (signed) */
+#define PROGRAM1000_PMODE_SAMPLE		0x00
+#define PROGRAM1000_PMODE_LOOP			0x01
+#define PROGRAM1000_PMODE_LOOPNOTREL	0x02
+#define PROGRAM1000_PMODE_NOLOOP		0x03
+#define PROGRAM1000_PMODE_TOEND			0x04
+	u_char pmode;       /* playback mode */
+	u_char dummy1[2];   /* XXX */
+#define PROGRAM1000KG_SHDRA_NONE		0xffff /* value for none */
+	u_char shdra[2];	/* address of sample header (updated by sampler) */
+}; /* Note: should be 0x0018 Bytes */
+
+/* AKAI S1000 program: keygroup */
+struct akai_program1000kg_s{
+#define PROGRAM1000KG_BLOCKID	0x02
+	u_char blockid;      /* block ID */
+	u_char kgnexta[2];   /* address of next keygroup (updated by sampler) */
+	u_char keylo;        /* low MIDI key */
+	u_char keyhi;        /* high MIDI key */
+	u_char ctune;        /* cents tune offset (signed) */
+	u_char stune;        /* semitone tune offset (signed) */
+	u_char filter;       /* filter */
+	u_char dummy1[22];   /* XXX */
+	u_char velxf;        /* velocity crossfade enable */
+	u_char dummy2[3];    /* XXX */
+#define PROGRAM1000KG_VELZONENUM	4 /* number of velocity zones per keygroup */
+	struct akai_program1000kgvelzone_s velzone[PROGRAM1000KG_VELZONENUM]; /* velocity zones */
+	u_char dummy3[2];    /* XXX */
+	u_char pconst[PROGRAM1000KG_VELZONENUM]; /* constant pitch enable for velocity zones */
+	u_char auxchoff[PROGRAM1000KG_VELZONENUM]; /* aux output channel offsets for velocity zones */
+	u_char dummy4[10];   /* XXX */
+}; /* Note: should be 0x0096 Bytes */
+
+#define AKAI_PROGRAM1000_FTYPE	'p' /* file type */
+
+
+
+/* AKAI S3000 program header */
+struct akai_program3000_s{
+#define PROGRAM3000_BLOCKID		PROGRAM1000_BLOCKID
+	struct akai_program1000_s s1000;
+	u_char dummy1[42];  /* XXX */
+}; /* Note: should be 0x00c0 Bytes */
+/* Note: header is followed by keygroups */
+
+/* AKAI S3000 program: keygroup */
+struct akai_program3000kg_s{
+#define PROGRAM3000KG_BLOCKID	PROGRAM1000KG_BLOCKID
+	struct akai_program1000kg_s s1000;
+	u_char dummy1[42];  /* XXX */
+}; /* Note: should be 0x00c0 Bytes */
+
+/* address multiplicands */
+#define PROGRAM3000_KGA_MULT	0x10
+#define PROGRAM3000_SHDRA_MULT	0x10
+
+#define AKAI_PROGRAM3000_FTYPE	('p'+0x80) /* file type */
+
+
+
+/* AKAI S1000 or S3000 drum settings descriptor */
+struct akai_drum1000des_s{
+	u_char midich1;  /* MIDI channel-1 */
+	u_char midinote; /* MIDI note */
+	u_char sens;     /* sensitivity level */
+	u_char trig;     /* trigger level */
+	u_char vcurv1;   /* "V-curve"-1 */
+	u_char captt;    /* capture time in msec */
+	u_char recovt;   /* recovery time in msec */
+	u_char ontime;   /* on-time in msec */
+	u_char dummy1;   /* XXX */
+}; /* Note: should be 0x0009 Bytes */
+
+/* AKAI S1000 or S3000 drum settings file */
+struct akai_drum1000_s{
+#define DRUM1000_BLOCKID		0x01
+	u_char blockid;   /* block ID */
+	u_char dummy1[2]; /* XXX */
+	u_char name[AKAI_NAME_LEN]; /* drum settings name (in RAM) */
+#define DRUM1000_UNITNUM		2 /* number of units */
+#define DRUM1000_INPUTNUM		8 /* number of drum trigger inputs per unit */
+	struct akai_drum1000des_s ddes1[DRUM1000_INPUTNUM]; /* drum setting descriptors for unit 1 */
+	u_char dummy2[3]; /* XXX */
+	struct akai_drum1000des_s ddes2[DRUM1000_INPUTNUM]; /* drum setting descriptors for unit 2 */
+}; /* Note: should be 0x00a2 Bytes */
+
+#define AKAI_DRUM1000_FTYPE		'd' /* file type */
+#define AKAI_DRUM1000_FNAME		"DRUM INPUTS " /* default file name */
+
+
+
+/* AKAI S1100 or S3000 or S3000XL effects file */
+/* Note: effects files of different system types are incompatible */
+#define AKAI_FXFILE_FTYPE		'x' /* file type */
+#define AKAI_FXFILE_FNAME		"EFFECTS FILE" /* default file name */
+#define AKAI_FXFILE_FSIZE		0x1c90 /* default file size */
+#define FXFILE1100_BLOCKID		0x00
+#define FXFILE3000_BLOCKID		0x00
+#define FXFILE3000XL_BLOCKID	0x02
+
+
+
+/* AKAI S1100 or S3000 cue/take-list header */
+struct akai_cuelist_s{
+#define CUELIST_BLOCKID		0x00
+	u_char blockid;      /* block ID */
+	u_char dummy1[2];    /* XXX */
+	u_char name[AKAI_NAME_LEN]; /* cue/take-list name (in RAM) */
+	u_char dummy2[7];    /* XXX */
+	u_char cuenum;       /* number of cues */
+	u_char dummy3[105];  /* XXX */
+}; /* Note: should be 0x0080 Bytes */
+/* Note: header is followed by cues */
+
+/* AKAI S1100 or S3000 cue */
+/* Note: depending on file/cue type, some struct elements are ignored */
+struct akai_cue_s{
+	u_char name[AKAI_NAME_LEN]; /* program or take name */
+	u_char time[5];      /* time (BCD format) */
+#define AKAI_CUETYPE_MOFF	0x00 /* program: MIDI note off */
+#define AKAI_CUETYPE_MON	0x01 /* program: MIDI note on */
+#define AKAI_CUETYPE_TOFF	0x02 /* DD take: off */
+#define AKAI_CUETYPE_TON	0x03 /* DD take: on */
+	u_char type;         /* cue type */
+	u_char midinote;     /* MIDI note */
+	u_char midivel;      /* MIDI velocity */
+	u_char pan;          /* panning (signed) */
+	u_char stlvl;        /* stereo output level */
+	u_char midich1;      /* MIDI channel-1 */
+	u_char repeat1;      /* repeat count-1 */
+	u_char fadein[2];    /* fade in time in ms */
+	u_char fadeout[2];   /* fade out time in ms */
+	u_char dummy1[4];    /* XXX */
+}; /* Note: should be 0x0020 Bytes */
+
+#define AKAI_QLFILE_FTYPE		'q' /* cue-list file type */
+#define AKAI_QLFILE_FNAME		"QL1         " /* default cue-list file name */
+
+#define AKAI_TLFILE_FTYPE		't' /* take-list file type */
+#define AKAI_TLFILE_FNAME		"TL1         " /* default take-list file name */
+
+
+
+/* AKAI S3000 multi file */
+#define AKAI_MULTI3000_FTYPE	('m'+0x80) /* file type */
+#define AKAI_MULTI3000_FNAME	"MULTI FILE  " /* default file name */
+#define MULTI3000_BLOCKID		0x00
+
+
+
+/* AKAI S1000 operating system file */
+#define AKAI_SYS1000_FTYPE	'c' /* file type */
+
+/* AKAI S3000 operating system file */
+#define AKAI_SYS3000_FTYPE	('c'+0x80) /* file type */
+
+
+
+/* AKAI CD3000 CD-ROM setup header */
+/* Note: generic file header does not apply for this file type! */
+struct akai_cdsetup3000_s{
+	u_char name[AKAI_NAME_LEN]; /* CD-ROM setup name (in RAM) */
+	u_char dummy1[3]; /* XXX */
+	u_char cdlabel[AKAI_NAME_LEN]; /* CD-ROM label */
+}; /* Note: should be 0x006b Bytes */
+/* followed by marked file entries */
+
+/* marked file entry */
+struct akai_cdsetup3000_entry_s{
+	u_char parti;    /* partition index */
+	u_char voli;     /* volume index */
+	u_char filei[2]; /* file index */
+}; /* Note: should be 4 Bytes */
+/* Note: unused entry is 0xff 0xff 0xff 0xff */
+
+#define AKAI_CDSETUP3000_FTYPE	'T' /* file type */
+/* Note: AKAI_CDSETUP3000_FTYPE is within range of file types for S900 */
+#define AKAI_CDSETUP3000_FNAME	"NEW CD SETUP" /* default file name */
+
+
+
+/* Declarations */
+
+extern int akai_file_info(struct file_s *fp,int verbose);
+extern void akai_sample_info(struct file_s *fp,u_char *hdrp);
+extern int akai_program_info(struct file_s *fp);
+extern int akai_cuelist_info(struct file_s *fp);
+extern int akai_takelist_info(struct file_s *fp);
+extern int akai_drum1000_info(struct file_s *fp);
+extern int akai_drum900_info(struct file_s *fp);
+extern int akai_ovs900_info(struct file_s *fp);
+extern int akai_cdsetup3000_info(struct file_s *fp);
+
+extern int akai_fixramname(struct file_s *fp);
+
+extern int akai_s900comprfile_updateuncompr(struct file_s *fp);
+
+extern u_int akai_sample900_getsamplesize(struct file_s *fp);
+
+extern void akai_sample900noncompr_sample2wav(u_char *sbuf,u_char *wavbuf,u_int samplecountpart);
+extern void akai_sample900noncompr_wav2sample(u_char *sbuf,u_char *wavbuf,u_int samplecountpart);
+
+extern u_int akai_sample900compr_getbits(u_char *buf,u_int bitpos,u_int bitnum);
+extern u_int akai_sample900compr_sample2wav(u_char *sbuf,u_char *wavbuf,u_int sbufsiz,u_int wavbufsiz);
+extern void akai_sample900compr_setbits(u_char *buf,u_int bitpos,u_int bitnum,u_int val);
+extern int akai_sample900compr_wav2sample(u_char *sbuf,u_char *wavbuf,u_int samplecountpart);
+
+extern int akai_sample900_noncompr2compr(struct file_s *fp,struct vol_s *volp);
+extern int akai_sample900_compr2noncompr(struct file_s *fp,struct vol_s *volp);
+
+#define SAMPLE2WAV_CHECK		1
+#define SAMPLE2WAV_EXPORT		2
+#define SAMPLE2WAV_CREATE		4
+#define SAMPLE2WAV_ALL			0xff
+extern int akai_sample2wav(struct file_s *fp,int wavfd,u_int *sizep,char **wavnamep,int what);
+
+#define WAV2SAMPLE_OPEN			1
+#define WAV2SAMPLE_OVERWRITE	2
+extern int akai_wav2sample(int wavfd,char *wavname,struct vol_s *volp,u_int findex,
+						   u_int type,int s9cflag,u_int osver,u_char *tagp,
+						   u_int *bcountp,int what);
+
+
+
+#endif /* !__AKAIUTIL_FILE_H */
diff --git a/third_party/akaiutil/akaiutil_io.c b/third_party/akaiutil/akaiutil_io.c
new file mode 100755
index 0000000..9d4ec1e
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_io.c
@@ -0,0 +1,865 @@
+/*
+* Copyright (C) 2008,2019,2020,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+#include "akaiutil_io.h"
+
+
+
+#ifdef _VISUALCPP
+/* for low-level floppy I/O, using fdrawcmd.sys */
+#include "fdrawcmd.h" /* from http://simonowen.com/fdrawcmd/fdrawcmd.h */
+
+HANDLE fldr_h[FLDRNUM]; /* handle for floppy drive */
+u_int fldr_type[FLDRNUM]; /* floppy drive type */
+PBYTE fldr_secbuf; /* DMA buffer for sector */
+
+int
+fldr_init(void)
+{
+	u_int i;
+
+	for (i=0;i<FLDRNUM;i++){
+		fldr_h[i]=INVALID_HANDLE_VALUE;
+		fldr_type[i]=FLDR_TYPE_FLL; /* XXX */
+	}
+
+	/* allocate DMA buffer for sector */
+	fldr_secbuf=(PBYTE)VirtualAlloc(NULL,AKAI_FL_SECSIZE,MEM_COMMIT,PAGE_READWRITE);
+	if (fldr_secbuf==NULL){
+		PRINTF_ERR("fldr_init: cannot allocate DMA buffer\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+void
+fldr_end(void)
+{
+	u_int i;
+
+	for (i=0;i<FLDRNUM;i++){
+		if (fldr_h[i]!=INVALID_HANDLE_VALUE){
+			CloseHandle(fldr_h[i]);
+			fldr_h[i]=INVALID_HANDLE_VALUE;
+		}
+	}
+	if (fldr_secbuf!=NULL){
+		VirtualFree(fldr_secbuf,0,MEM_RELEASE);
+		fldr_secbuf=NULL;
+	}
+}
+
+int
+fldr_open(int fldrn,u_int fldrtype)
+{
+	static char devname[32]; /* XXX */
+	HANDLE h;
+	DWORD version;
+	BYTE datarate;
+	DWORD ret;
+
+	if ((fldrn<0)||(fldrn>=FLDRNUM)){
+		PRINTF_ERR("fldr_open: invalid floppy drive number\n");
+		return -1;
+	}
+	if (fldr_h[fldrn]!=INVALID_HANDLE_VALUE){
+		PRINTF_ERR("fldr_open: floppy drive already opened\n");
+		return -1;
+	}
+
+	/* check driver */
+	version=0; /* invalid */
+	/* Note: must use GENERIC_READ|GENERIC_WRITE for DeviceIoControl() */
+	h=CreateFileA("\\\\.\\fdrawcmd",GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL);
+	if (h!=INVALID_HANDLE_VALUE){
+		if (!DeviceIoControl(h,IOCTL_FDRAWCMD_GET_VERSION,NULL,0,&version,sizeof(version),&ret,NULL)){
+			version=0; /* invalid */
+		}
+		CloseHandle(h);
+	}
+	if (version==0){
+		PRINTF_ERR("fldr_open: fdrawcmd.sys is not installed, see: http://simonowen.com/fdrawcmd/\n");
+		return -1;
+	}
+	if (HIWORD(version)!=HIWORD(FDRAWCMD_VERSION)){
+		PRINTF_ERR("fldr_open: the installed fdrawcmd.sys is not compatible with this program\n");
+		return -1;
+	}
+
+	/* open and init device */
+    sprintf(devname,"\\\\.\\fdraw%u",(u_int)fldrn);
+	/* Note: must use GENERIC_READ|GENERIC_WRITE for DeviceIoControl() */
+    h=CreateFileA(devname,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,0,NULL);
+	if (h==INVALID_HANDLE_VALUE){
+		PRINTF_ERR("fldr_open: cannot open floppy drive\n");
+		return -1;
+	}
+	if (fldrtype==FLDR_TYPE_FLH){
+		datarate=AKAI_FLH_DISK_DATARATE;
+	}else{
+		datarate=AKAI_FLL_DISK_DATARATE;
+	}
+	if (!DeviceIoControl(h,IOCTL_FD_SET_DATA_RATE,&datarate,sizeof(datarate),NULL,0,&ret,NULL)){
+		PRINTF_ERR("fldr_open: cannot set floppy data rate\n");
+		CloseHandle(h);
+		return -1;
+	}
+	if (!DeviceIoControl(h,IOCTL_FD_RESET,NULL,0,NULL,0,&ret,NULL)){
+		PRINTF_ERR("fldr_open: cannot reset floppy controller\n");
+		CloseHandle(h);
+		return -1;
+	}
+
+	/* save handle and type */
+	fldr_h[fldrn]=h;
+	fldr_type[fldrn]=fldrtype;
+
+	return 0;
+}
+
+int
+fldr_checkfloppyinserted(int fldrn)
+{
+	DWORD ret;
+
+	if ((fldrn<0)||(fldrn>=FLDRNUM)||(fldr_h[fldrn]==INVALID_HANDLE_VALUE)){
+		return -1;
+	}
+
+	/* check if no floppy inserted */
+	if (!DeviceIoControl(fldr_h[fldrn],IOCTL_FD_CHECK_DISK,NULL,0,NULL,0,&ret,NULL)){
+		return -1;
+	}
+
+	return 0; /* floppy is inserted */
+}
+
+int
+fldr_io_direct(int fldrn,u_int blk,u_char *buf,int mode)
+{
+	BYTE cyl;
+	BYTE head;
+	BYTE sec;
+	DWORD ret;
+    FD_READ_WRITE_PARAMS rwp;
+	u_int retry;
+	int retval;
+
+	if ((fldrn<0)||(fldrn>=FLDRNUM)||(fldr_h[fldrn]==INVALID_HANDLE_VALUE)||(buf==NULL)){
+		return -1;
+	}
+	if ((mode!=IO_BLKS_READ)&&(mode!=IO_BLKS_WRITE)){
+		return -1;
+	}
+
+	if (fldr_type[fldrn]==FLDR_TYPE_FLH){
+		cyl=blk/(AKAI_FL_DISK_SIDES*AKAI_FLH_DISK_SECTORS);
+		head=1&(blk/AKAI_FLH_DISK_SECTORS);
+		sec=AKAI_FL_SECTOR_BASE+(blk%AKAI_FLH_DISK_SECTORS);
+	}else{
+		cyl=blk/(AKAI_FL_DISK_SIDES*AKAI_FLL_DISK_SECTORS);
+		head=1&(blk/AKAI_FLL_DISK_SECTORS);
+		sec=AKAI_FL_SECTOR_BASE+(blk%AKAI_FLL_DISK_SECTORS);
+	}
+#ifdef DEBUG
+	PRINTF_OUT("fldr_io_direct: cyl=%u head=%u sec=%u\n",(u_int)cyl,(u_int)head,(u_int)sec);
+#endif
+
+	/* check if no floppy inserted */
+	if (!DeviceIoControl(fldr_h[fldrn],IOCTL_FD_CHECK_DISK,NULL,0,NULL,0,&ret,NULL)){
+		return -1;
+	}
+
+	/* goto track */
+	if (!DeviceIoControl(fldr_h[fldrn],IOCTL_FDCMD_SEEK,&cyl,sizeof(cyl),NULL,0,&ret,NULL)){
+		return -1;
+	}
+
+	/* set parameters */
+	rwp.flags=FD_OPTION_MFM;
+	rwp.phead=head;
+	rwp.cyl=cyl;
+	rwp.head=head;
+	rwp.sector=sec;
+	rwp.size=AKAI_FL_SECTOR_SIZE_CODE;
+	rwp.eot=sec+1; /* for IOCTL_FDCMD_READ_DATA,IOCTL_FDCMD_WRITE_DATA: last sector number+1 !!! */
+	rwp.gap=0x0a;
+	rwp.datalen=0xff;
+
+	retval=0; /* no error so far */
+	if (mode==IO_BLKS_WRITE){
+		/* copy sector from buf to DMA buffer */
+		bcopy(buf,(u_char *)fldr_secbuf,AKAI_FL_SECSIZE);
+
+		for (retry=0;retry<FLDR_RETRYMAX;retry++){
+			/* write sector */
+			if (DeviceIoControl(fldr_h[fldrn],IOCTL_FDCMD_WRITE_DATA,&rwp,sizeof(rwp),(PVOID)fldr_secbuf,AKAI_FL_SECSIZE,&ret,NULL)){
+				break;
+			}
+		}
+		if (retry>=FLDR_RETRYMAX){
+			retval=-1; /* error */
+		}
+	}else{
+		for (retry=0;retry<FLDR_RETRYMAX;retry++){
+			/* read sector */
+			if (DeviceIoControl(fldr_h[fldrn],IOCTL_FDCMD_READ_DATA,&rwp,sizeof(rwp),(PVOID)fldr_secbuf,AKAI_FL_SECSIZE,&ret,NULL)){
+				break;
+			}
+		}
+		if (retry>=FLDR_RETRYMAX){
+			retval=-1; /* error */
+		}
+
+		/* copy sector from DMA buffer to buf */
+		/* Note: even if DeviceIoControl() above returned an error */
+		/*       in this case, DMA buffer could contain leftover from last call */
+		/*       or could contain correct complete or partial sector */
+		/*       -> let caller decide what to do with buf in case of an error */
+		bcopy((u_char *)fldr_secbuf,buf,AKAI_FL_SECSIZE);
+	}
+
+	return retval;
+}
+
+int
+fldr_format(int fldrn)
+{
+	BYTE cyl;
+	BYTE head;
+	BYTE sec;
+	BYTE secnum;
+	BYTE secgap3;
+	BYTE secoffset;
+	BYTE trackskew;
+	DWORD ret;
+    static BYTE fpbuf[sizeof(FD_FORMAT_PARAMS)+sizeof(FD_ID_HEADER)*AKAI_FLH_DISK_SECTORS]; /* space for max. track size */
+    PFD_FORMAT_PARAMS fpp;
+	DWORD fpsize;
+#ifndef FLDR_FORMAT_NOVERIFY
+    FD_READ_WRITE_PARAMS rwp;
+#endif
+	u_int retry;
+	int retval;
+
+	if ((fldrn<0)||(fldrn>=FLDRNUM)||(fldr_h[fldrn]==INVALID_HANDLE_VALUE)){
+		return -1;
+	}
+
+	if (fldr_type[fldrn]==FLDR_TYPE_FLH){
+		secnum=AKAI_FLH_DISK_SECTORS;
+		secgap3=AKAI_FLH_SECTOR_GAP3;
+		secoffset=AKAI_FLH_SECTOR_OFFSET;
+		trackskew=AKAI_FLH_TRACK_SKEW;
+	}else{
+		secnum=AKAI_FLL_DISK_SECTORS;
+		secgap3=AKAI_FLL_SECTOR_GAP3;
+		secoffset=AKAI_FLL_SECTOR_OFFSET;
+		trackskew=AKAI_FLL_TRACK_SKEW;
+	}
+
+	retval=0; /* no error so far */
+	fpp=(PFD_FORMAT_PARAMS)fpbuf;
+	fpsize=sizeof(FD_FORMAT_PARAMS)+secnum*sizeof(FD_ID_HEADER);
+	for (cyl=0;cyl<AKAI_FL_DISK_TRACKS;cyl++){
+		/* check if no floppy inserted */
+		if (!DeviceIoControl(fldr_h[fldrn],IOCTL_FD_CHECK_DISK,NULL,0,NULL,0,&ret,NULL)){
+			PRINTF_OUT("\rno floppy inserted          \n",((u_int)cyl)+1);
+			FLUSH_ALL;
+			return -1;
+		}
+
+		/* goto track */
+		if (!DeviceIoControl(fldr_h[fldrn],IOCTL_FDCMD_SEEK,&cyl,sizeof(cyl),NULL,0,&ret,NULL)){
+			PRINTF_OUT("\rtrack %u - cannot seek track\n",((u_int)cyl)+1);
+			FLUSH_ALL;
+			return -1;
+		}
+
+		for (head=0;head<AKAI_FL_DISK_SIDES;head++){
+			PRINTF_OUT("\rtrack %u side %u",((u_int)cyl)+1,((u_int)head)+1);
+			FLUSH_ALL;
+
+			/* set parameters */
+			fpp->flags=FD_OPTION_MFM;
+			fpp->phead=head;
+			fpp->size=AKAI_FL_SECTOR_SIZE_CODE;
+			fpp->sectors=secnum;
+			fpp->gap=secgap3;
+			fpp->fill=AKAI_FL_SECTOR_FILL;
+			for (sec=0;sec<secnum;sec++){
+				fpp->Header[sec].cyl=cyl;
+				fpp->Header[sec].head=head;
+				fpp->Header[sec].sector=AKAI_FL_SECTOR_BASE+((secoffset+sec+cyl*(secnum-trackskew))%secnum);
+				fpp->Header[sec].size=AKAI_FL_SECTOR_SIZE_CODE;
+			}
+#ifndef FLDR_FORMAT_NOVERIFY
+			rwp.flags=FD_OPTION_MFM;
+			rwp.phead=head;
+			rwp.cyl=cyl;
+			rwp.head=head;
+			rwp.sector=AKAI_FL_SECTOR_BASE;
+			rwp.size=AKAI_FL_SECTOR_SIZE_CODE;
+			rwp.eot=AKAI_FL_SECTOR_BASE+secnum-1; /* for IOCTL_FDCMD_VERIFY: last sector number !!! */
+			rwp.gap=0x0a;
+			rwp.datalen=0xff;
+#endif
+
+			for (retry=0;retry<FLDR_RETRYMAX;retry++){
+				/* format track */
+				if (DeviceIoControl(fldr_h[fldrn],IOCTL_FDCMD_FORMAT_TRACK,fpp,fpsize,NULL,0,&ret,NULL)){
+#ifndef FLDR_FORMAT_NOVERIFY
+					/* verify track */
+					if (DeviceIoControl(fldr_h[fldrn],IOCTL_FDCMD_VERIFY,&rwp,sizeof(rwp),NULL,0,&ret,NULL))
+#endif
+					{
+						break;
+					}
+				}
+			}
+			if (retry>=FLDR_RETRYMAX){
+				PRINTF_OUT(" - cannot format track\n");
+				FLUSH_ALL;
+#if 1
+				/* XXX ignore error, continue */
+				retval=-1;
+#else
+				return -1;
+#endif
+			}
+		}
+	}
+	PRINTF_OUT("\rdone                           \n");
+	FLUSH_ALL;
+
+	return retval;
+}
+#endif /* _VISUALCPP */
+
+
+
+/* cache */
+
+struct blk_cache_s blk_cache[BLK_CACHE_NUM];
+int blk_cache_enable;
+
+
+
+void
+init_blk_cache(void)
+{
+	int i;
+
+	for (i=0;i<BLK_CACHE_NUM;i++){
+		blk_cache[i].valid=0; /* free entry */
+		blk_cache[i].buf=NULL; /* not allocated yet */
+	}
+}
+
+
+
+void
+free_blk_cache(void)
+{
+	int i;
+
+	for (i=0;i<BLK_CACHE_NUM;i++){
+		if (blk_cache[i].buf!=NULL){ /* buffer allocated? */
+			/* free buffer */
+			free(blk_cache[i].buf);
+			blk_cache[i].valid=0; /* free entry */
+			blk_cache[i].buf=NULL; /* not allocated yet */
+		}
+	}
+}
+
+
+
+void
+print_blk_cache(void)
+{
+	int i;
+
+#ifdef _VISUALCPP
+	PRINTF_OUT("nr    fd   fldrn start/B       blksize blk     age         mod\n");
+	PRINTF_OUT("--------------------------------------------------------------\n");
+#else /* !_VISUALCPP */
+	PRINTF_OUT("nr    fd   start/B       blksize blk     age         mod\n");
+	PRINTF_OUT("--------------------------------------------------------\n");
+#endif /* !_VISUALCPP */
+	for (i=0;i<BLK_CACHE_NUM;i++){
+		if (!blk_cache[i].valid){ /* free entry? */
+			continue; /* next */
+		}
+#ifdef _VISUALCPP
+		PRINTF_OUT("%4i  %3i  %3i   0x%02x%08x  0x%04x  0x%04x  0x%08x  %i\n",
+			i,
+			blk_cache[i].fd,
+			blk_cache[i].fldrn,
+			(u_int)(blk_cache[i].startoff>>32),
+			(u_int)(0xffffffff&blk_cache[i].startoff),
+			blk_cache[i].blksize,
+			blk_cache[i].blk,
+			blk_cache[i].age,
+			blk_cache[i].modified);
+#else /* !_VISUALCPP */
+		PRINTF_OUT("%4i  %3i  0x%02x%08x  0x%04x  0x%04x  0x%08x  %i\n",
+			i,
+			blk_cache[i].fd,
+			(u_int)(blk_cache[i].startoff>>32),
+			(u_int)(0xffffffff&blk_cache[i].startoff),
+			blk_cache[i].blksize,
+			blk_cache[i].blk,
+			blk_cache[i].age,
+			blk_cache[i].modified);
+#endif /* !_VISUALCPP */
+	}
+#ifdef _VISUALCPP
+	PRINTF_OUT("--------------------------------------------------------------\n");
+#else /* !_VISUALCPP */
+	PRINTF_OUT("--------------------------------------------------------\n");
+#endif /* !_VISUALCPP */
+}
+
+
+
+int
+find_blk_cache(int fd,
+#ifdef _VISUALCPP
+			   int fldrn,
+#endif /* _VISUALCPP */
+			   OFF64_T startoff,u_int blk,u_int blksize)
+{
+	int i;
+
+	/* scan cache */
+	for (i=0;i<BLK_CACHE_NUM;i++){
+		if (blk_cache[i].buf==NULL){
+			continue; /* next */
+		}
+		if (!blk_cache[i].valid){ /* free? */
+			continue; /* next */
+		}
+		/* check if contained within cache */
+		/* Note: must check for blksize as well!!! */
+		if ((fd==blk_cache[i].fd)
+#ifdef _VISUALCPP
+			&&(fldrn==blk_cache[i].fldrn)
+#endif /* _VISUALCPP */
+			&&(startoff==blk_cache[i].startoff)
+			&&(blk==blk_cache[i].blk)
+			&&(blksize==blk_cache[i].blksize)){
+			break; /* found it */
+		}
+	}
+
+	if (i==BLK_CACHE_NUM){ /* none found? */
+		return -1;
+	}
+
+	return i;
+}
+
+
+
+void
+blk_cache_aging(int i)
+{
+	int j;
+	u_int agemin;
+
+	if ((i<0)||(i>=BLK_CACHE_NUM)||(!blk_cache[i].valid)){
+		return;
+	}
+
+	blk_cache[i].age=0; /* reset age */
+
+	/* find the youngest of the others */
+	agemin=BLK_CACHE_AGE_MAX;
+	for (j=0;j<BLK_CACHE_NUM;j++){
+		if (!blk_cache[j].valid){ /* free? */
+			continue; /* next */
+		}
+		if (j==i){
+			continue; /* next */
+		}
+		if (blk_cache[j].age<agemin){
+			agemin=blk_cache[j].age;
+		}
+	}
+	if (agemin==0){ /* somebody else too young? */
+		/* increment age of the others */
+		for (j=0;j<BLK_CACHE_NUM;j++){
+			if (j==i){
+				continue; /* next */
+			}
+			if (blk_cache[j].age<BLK_CACHE_AGE_MAX){
+				blk_cache[j].age++; /* increase age */
+			}
+		}
+	}
+}
+
+
+
+int
+io_blks_direct(int fd,
+#ifdef _VISUALCPP
+			   int fldrn,
+#endif /* _VISUALCPP */
+			   OFF64_T startoff,u_char *buf,u_int bstart,u_int bsize,u_int blksize,int cachealloc,int mode)
+{
+	int err;
+	int j,jmax;
+	u_int agemax;
+	u_int blk,blkmin,blkmax,blkchunk;
+
+	if (buf==NULL){
+		return -1;
+	}
+#ifdef _VISUALCPP
+	if ((fd<0)&&(fldrn<0)){
+		return -1;
+	}
+#else /* !_VISUALCPP */
+	if (fd<0){
+		return -1;
+	}
+#endif /* !_VISUALCPP */
+
+	if ((mode!=IO_BLKS_READ)&&(mode!=IO_BLKS_WRITE)){
+		return -1;
+	}
+
+	/* Note: OFF64_T against overflow */
+	if ((((OFF64_T)bstart)+((OFF64_T)bsize))>(OFF64_T)0xffffffff){ /* XXX */
+		return -1;
+	}
+
+	if (bsize==0){
+		return 0; /* done */
+	}
+
+	if (!blk_cache_enable){ /* cache disabled? */
+		cachealloc=0; /* don't allocate cache */
+	}
+
+	if (cachealloc /* must allocate cache? */
+#ifdef _VISUALCPP
+		||(fldrn>=0) /* or is floppy drive? */
+#endif /* _VISUALCPP */
+		){
+		/* single blocks */
+		blkmin=bstart;
+		blkmax=bstart+bsize;
+		blkchunk=1;
+	}else{
+		/* all blocks at once */
+		blkmin=bstart;
+		blkmax=bstart+1; /* fake value: only once */
+		blkchunk=bsize;
+	}
+
+	for (blk=blkmin;blk<blkmax;blk++){
+#ifdef _VISUALCPP
+		if (fldrn>=0){ /* is floppy drive? */
+			/* Note: ignore startoff if floppy drive */
+			if (fldr_io_direct(fldrn,blk,buf+(blk-blkmin)*blksize,mode)<0){
+				return -1;
+			}
+		}else /* no floppy drive */
+#endif /* _VISUALCPP */
+		{
+			/* goto blk */
+			if (LSEEK64(fd,startoff+(OFF64_T)(blk*blksize),SEEK_SET)<0){
+#ifdef DEBUG
+				PERROR("lseek");
+#endif
+				return -1;
+			}
+			if (mode==IO_BLKS_WRITE){
+				/* write block(s) */
+				err=WRITE(fd,(void *)(buf+(blk-blkmin)*blksize),blkchunk*blksize);
+				if (err<0){
+#ifdef DEBUG
+					PERROR("write");
+#endif
+					return -1;
+				}
+				if (err!=(int)(blkchunk*blksize)){
+#ifdef DEBUG
+					PRINTF_ERR("write: incomplete\n");
+#endif
+					return -1;
+				}
+			}else{
+				/* read block(s) */
+				err=READ(fd,(void *)(buf+(blk-blkmin)*blksize),blkchunk*blksize);
+				if (err<0){
+#ifdef DEBUG
+					PERROR("read");
+#endif
+					return -1;
+				}
+				if (err!=(int)(blkchunk*blksize)){
+#ifdef DEBUG
+					PRINTF_ERR("read: incomplete\n");
+#endif
+					return -1;
+				}
+			}
+		}
+		if (cachealloc){ /* must allocate cache? */
+			/* find free entry or the oldest one */
+			agemax=0;
+			jmax=0; /* first guess */
+			for (j=0;j<BLK_CACHE_NUM;j++){
+				if (!blk_cache[j].valid){ /* free? */
+					jmax=j;
+					break; /* found one */
+				}
+				if (blk_cache[j].age>=agemax){ /* older or equal? */
+					agemax=blk_cache[j].age;
+					jmax=j;
+				}
+			}
+			/* old cache entry not free and modified? */
+			err=0;
+			if ((blk_cache[jmax].valid)&&(blk_cache[jmax].modified)&&(blk_cache[jmax].buf!=NULL)){
+				/* must flush this block */
+				if (io_blks_direct(blk_cache[jmax].fd,
+#ifdef _VISUALCPP
+									blk_cache[jmax].fldrn,
+#endif /* _VISUALCPP */
+									blk_cache[jmax].startoff,
+									(u_char *)blk_cache[jmax].buf,
+									blk_cache[jmax].blk,
+									1,
+									blk_cache[jmax].blksize,
+									0, /* don't alloc cache */
+									IO_BLKS_WRITE)<0){
+					PRINTF_ERR("cannot flush cache block 0x%08x of fd %i\n",blk_cache[jmax].blk,blk_cache[jmax].fd);
+					err=1; /* cannot allocate below */
+				}
+			}
+			if (!err){
+				if ((blk_cache[jmax].buf!=NULL)&&(blk_cache[jmax].blksize!=blksize)){ /* not compatible? */
+					/* free buffer */
+					free(blk_cache[jmax].buf);
+					blk_cache[jmax].buf=NULL;
+				}
+				if (blk_cache[jmax].buf==NULL){ /* buffer not allocated yet/anymore? */
+					/* need to allocate buffer */
+					if ((blk_cache[jmax].buf=(u_char *)malloc(blksize))==NULL){
+						PERROR("malloc");
+						err=1; /* cannot allocate below */
+					}
+					blk_cache[jmax].valid=0; /* free */
+					blk_cache[jmax].blksize=blksize;
+				}
+			}
+			if (!err){
+				/* allocate cache entry */
+				blk_cache[jmax].valid=1;
+				blk_cache[jmax].modified=0;
+				blk_cache[jmax].fd=fd;
+#ifdef _VISUALCPP
+				blk_cache[jmax].fldrn=fldrn;
+#endif /* _VISUALCPP */
+				blk_cache[jmax].startoff=startoff;
+				blk_cache[jmax].blk=blk;
+				blk_cache_aging(jmax); /* adjust ages */
+				/* copy data */
+				bcopy(buf+(blk-blkmin)*blksize,blk_cache[jmax].buf,blksize);
+			}
+		}
+	}
+
+	return 0;
+}
+
+
+
+/* Note: prior to changing blksize of any device/file, must flush cache first !!! */
+int
+flush_blk_cache(void)
+{
+	int ret;
+	int i;
+
+	/* scan cache */
+	ret=0; /* no error so far */
+	for (i=0;i<BLK_CACHE_NUM;i++){
+		if (blk_cache[i].buf==NULL){
+			continue; /* next */
+		}
+		if (!blk_cache[i].valid){ /* free? */
+			continue; /* next */
+		}
+		if (!blk_cache[i].modified){ /* not modified? */
+			continue; /* next */
+		}
+		/* must write */
+		if (io_blks_direct(blk_cache[i].fd,
+#ifdef _VISUALCPP
+							blk_cache[i].fldrn,
+#endif /* _VISUALCPP */
+							blk_cache[i].startoff,
+							(u_char *)blk_cache[i].buf,
+							blk_cache[i].blk,
+							1,
+							blk_cache[i].blksize,
+							0, /* don't alloc cache */
+							IO_BLKS_WRITE)<0){
+			PRINTF_ERR("cannot flush cache block 0x%08x of fd %i\n",blk_cache[i].blk,blk_cache[i].fd);
+			/* XXX cannot do more now, maybe more luck next time */
+			ret=-1;
+		}else{
+			blk_cache[i].modified=0; /* done */
+		}
+	}
+
+	return ret;
+}
+
+
+
+int
+io_blks(int fd,
+#ifdef _VISUALCPP
+		int fldrn,
+#endif /* _VISUALCPP */
+		OFF64_T startoff,u_char *buf,u_int bstart,u_int bsize,u_int blksize,int cachealloc,int mode)
+{
+	int i;
+	u_int blk;
+	u_int chunkstart,chunksize;
+
+	if (buf==NULL){
+		return -1;
+	}
+
+	if ((mode!=IO_BLKS_READ)&&(mode!=IO_BLKS_WRITE)){
+		return -1;
+	}
+
+	/* Note: OFF64_T against overflow */
+	if ((((OFF64_T)bstart)+((OFF64_T)bsize))>(OFF64_T)0xffffffff){ /* XXX */
+		return -1;
+	}
+#ifdef _VISUALCPP
+	if ((fd<0)&&(fldrn<0)){
+		return -1;
+	}
+#else /* !_VISUALCPP */
+	if (fd<0){
+		return -1;
+	}
+#endif /* !_VISUALCPP */
+
+	if (!blk_cache_enable){ /* cache disabled? */
+		cachealloc=0; /* don't allocate cache */
+	}
+
+	/* check every block */
+	chunkstart=bstart;
+	chunksize=0; /* no chunk of missing blocks so far */
+	for (blk=bstart;blk<(bstart+bsize);blk++){
+		if (blk_cache_enable){ /* cache enabled? */
+			/* look in cache */
+			i=find_blk_cache(fd,
+#ifdef _VISUALCPP
+							 fldrn,
+#endif /* _VISUALCPP */
+							 startoff,blk,blksize);
+			/* Note: no match for blk if blksize has changed!!! */
+			/*       however, these cache entries can be reused if needed */
+		}else{
+			i=-1; /* not found in cache */
+		}
+		if (i<0){ /* not found in cache? */
+			if (chunksize==0){ /* new chunk of missing blocks? */
+				chunkstart=blk; /* start of chunk */
+			}
+			chunksize++; /* one more missing block */
+		}else{
+			/* found in cache */
+			/* Note: now, blk_cache[i].buf!=NULL */
+
+			/* Note: must do cache-I/O first, since io_blks_direct could steal i from cache */
+			if (mode==IO_BLKS_WRITE){
+				/* copy to cache */
+				bcopy(buf+(blk-bstart)*blksize,blk_cache[i].buf,blksize);
+				blk_cache[i].modified=1; /* modified */
+			}else{
+				/* copy from cache */
+				bcopy(blk_cache[i].buf,buf+(blk-bstart)*blksize,blksize);
+			}
+			blk_cache_aging(i); /* adjust ages */
+
+			/* chunk of missing blocks pending? */
+			if (chunksize>0){
+				/* must read or write */
+				if (io_blks_direct(fd,
+#ifdef _VISUALCPP
+									fldrn,
+#endif /* _VISUALCPP */
+									startoff,
+									(u_char *)(buf+(chunkstart-bstart)*blksize),
+									chunkstart,
+									chunksize,
+									blksize,
+									cachealloc,
+									mode)<0){
+					return -1;
+				}
+				chunksize=0; /* no chunk of missing blocks anymore */
+			}
+		}
+	}
+	/* one last time: chunk of missing blocks pending? */
+	if (chunksize>0){
+		/* must read or write */
+		if (io_blks_direct(fd,
+#ifdef _VISUALCPP
+							fldrn,
+#endif /* _VISUALCPP */
+							startoff,
+							(u_char *)(buf+(chunkstart-bstart)*blksize),
+							chunkstart,
+							chunksize,
+							blksize,
+							cachealloc,
+							mode)<0){
+			return -1;
+		}
+		chunksize=0; /* no chunk of missing blocks anymore */
+	}
+
+	return 0;
+}
+
+
+
+/* EOF */
diff --git a/third_party/akaiutil/akaiutil_io.h b/third_party/akaiutil/akaiutil_io.h
new file mode 100755
index 0000000..7c3eda9
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_io.h
@@ -0,0 +1,137 @@
+#ifndef __AKAIUTIL_IO_H
+#define __AKAIUTIL_IO_H
+/*
+* Copyright (C) 2008,2010,2012,2019,2020,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+
+
+
+#ifdef _VISUALCPP
+/* for low-level floppy I/O, using fdrawcmd.sys */
+#include "fdrawcmd.h" /* from http://simonowen.com/fdrawcmd/fdrawcmd.h */
+
+/* definitions for low-level format of floppy disks for AKAI samplers */
+#define AKAI_FL_DISK_SIDES			2				/* sides per disk */
+#define AKAI_FL_DISK_TRACKS			80				/* tracks per side */
+#define AKAI_FLL_DISK_SECTORS		5				/* sectors per track for low-density floppy */
+#define AKAI_FLH_DISK_SECTORS		10				/* sectors per track for high-density floppy */
+#define AKAI_FLL_DISK_DATARATE		FD_RATE_250K	/* data rate for low-density floppy */
+#define AKAI_FLH_DISK_DATARATE		FD_RATE_500K	/* data rate for high-density floppy */
+#define AKAI_FL_SECTOR_SIZE_CODE	3				/* sector size code: 3 -> (128<<3)==1024 */
+#define AKAI_FLL_SECTOR_GAP3		0x74			/* gap3 size between sectors for low-density floppy */
+#define AKAI_FLH_SECTOR_GAP3		0x74			/* gap3 size between sectors for high-density floppy */
+#define AKAI_FL_SECTOR_FILL			0x00			/* fill byte for formatted sectors */
+#define AKAI_FL_SECTOR_BASE			1				/* first sector number on track */
+#define AKAI_FLL_SECTOR_OFFSET		3				/* sector number offset for low-density floppy */
+#define AKAI_FLH_SECTOR_OFFSET		6				/* sector number offset for high-density floppy */
+#define AKAI_FLL_TRACK_SKEW			2				/* skew to the same sector on the next track for low-density floppy */
+#define AKAI_FLH_TRACK_SKEW			4				/* skew to the same sector on the next track for high-density floppy */
+
+/* low-level floppy sector size */
+#define AKAI_FL_SECSIZE		0x0400 /* 1KB */
+/* Note: must be == AKAI_FL_BLOCKSIZE (floppy filesystem blocksize, defined in akaiutil.h) */
+#if defined(AKAI_FL_BLOCKSIZE)&&(AKAI_FL_SECSIZE!=AKAI_FL_BLOCKSIZE)
+#error "AKAI_FL_SECSIZE!=AKAI_FL_BLOCKSIZE"
+#endif
+
+#ifndef FLDRNUM
+#define FLDRNUM		2 /* XXX max. number of floppy drives */
+#endif
+extern HANDLE fldr_h[FLDRNUM]; /* handle for floppy drive */
+#define FLDR_TYPE_FLL		0 /* low-density floppy */
+#define FLDR_TYPE_FLH		1 /* high-density floppy */
+extern u_int fldr_type[FLDRNUM]; /* floppy drive type */
+extern PBYTE fldr_secbuf; /* DMA buffer for sector */
+
+#ifndef FLDR_RETRYMAX
+#define FLDR_RETRYMAX	5 /* XXX max. number of retries for floppy I/O */
+#endif
+#endif /* _VISUALCPP */
+
+
+
+/* cache */
+
+struct blk_cache_s{
+	int valid;
+	int modified;
+	int fd;
+#ifdef _VISUALCPP
+	int fldrn;
+#endif /* _VISUALCPP */
+	OFF64_T startoff;
+	u_int blk;
+	u_int blksize;
+#define BLK_CACHE_AGE_MAX		0xffffffff /* XXX max. age */
+	u_int age; /* age */
+	u_char *buf;
+};
+
+#ifndef BLK_CACHE_NUM
+#define BLK_CACHE_NUM	512 /* XXX */
+#endif
+extern struct blk_cache_s blk_cache[BLK_CACHE_NUM];
+
+extern int blk_cache_enable;
+
+
+
+#define IO_BLKS_READ	0
+#define IO_BLKS_WRITE	1
+
+
+
+/* Declarations */
+
+#ifdef _VISUALCPP
+extern int fldr_init(void);
+extern void fldr_end(void);
+extern int fldr_open(int fldrn,u_int fldrtype);
+extern int fldr_checkfloppyinserted(int fldrn);
+extern int fldr_io_direct(int fldrn,u_int blk,u_char *buf,int mode);
+extern int fldr_format(int fldrn);
+#endif /* _VISUALCPP */
+extern void init_blk_cache(void);
+extern void free_blk_cache(void);
+extern void print_blk_cache(void);
+extern int find_blk_cache(int fd,
+#ifdef _VISUALCPP
+						  int fldrnr,
+#endif
+						  OFF64_T startoff,u_int blk,u_int blksize);
+extern void blk_cache_aging(int i);
+extern int io_blks_direct(int fd,
+#ifdef _VISUALCPP
+						  int fldrn,
+#endif
+						  OFF64_T startoff,u_char *buf,u_int bstart,u_int bsize,u_int blksize,int cachealloc,int mode);
+extern int flush_blk_cache(void);
+extern int io_blks(int fd,
+#ifdef _VISUALCPP
+				   int fldrn,
+#endif
+				   OFF64_T startoff,u_char *buf,u_int bstart,u_int bsize,u_int blksize,int cachealloc,int mode);
+
+
+
+#endif /* !__AKAIUTIL_IO_H */
diff --git a/third_party/akaiutil/akaiutil_main.c b/third_party/akaiutil/akaiutil_main.c
new file mode 100755
index 0000000..abfb9c1
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_main.c
@@ -0,0 +1,5651 @@
+/*
+* Copyright (C) 2008-2022 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+/* akaiutil: access to AKAI S900/S1000/S3000 filesystems */
+
+
+
+#include "commoninclude.h"
+#include "akaiutil_io.h"
+#include "akaiutil.h"
+#include "akaiutil_tar.h"
+#include "akaiutil_file.h"
+#include "akaiutil_take.h"
+
+
+
+/* console user interface */
+#ifndef AKAIUTIL_MAIN
+#define AKAIUTIL_MAIN(...)			main(__VA_ARGS__)
+#endif
+#ifndef AKAIUTIL_EXIT
+#define AKAIUTIL_EXIT(...)			exit(__VA_ARGS__)
+#endif
+
+
+
+static void
+print_progressbar(u_int end,u_int now)
+{
+	static double xold; /* must be static */
+
+	if (end==0){
+		return;
+	}
+	if (now>end){
+		now=end;
+	}
+
+	if (now==0){
+		PRINTF_OUT("0         20        40        60        80        100%%\n.");
+		xold=0.0;
+	}
+
+	for (;((double)now)/(double)end-xold>=0.02;xold+=0.02){
+		PRINTF_OUT(".");
+	}
+
+	FLUSH_ALL;
+}
+
+
+
+static void
+usage(char *name)
+{
+
+	if (name==NULL){
+		return;
+	}
+
+#ifdef _VISUALCPP
+	PRINTF_ERR("usage: %s [-h] [-r] [-F] [-C] [-l <lock-file>] [-o <start-offset>] [-s <pseudo-disk-size>] [-n <pseudo-disk-number>] [-c <cdrom-index> ...] [-p <physdrive-index> ...] [[-f] <floppy-drive> ...] [[-f] <disk-file> ...]\n",name);
+	PRINTF_ERR("\t-h\tprint this info\n");
+	PRINTF_ERR("\t-r\tread-only mode\n");
+	PRINTF_ERR("\t-F\tdisable floppy filesystem for disk-files/CD-ROM drives/physical drives\n");
+	PRINTF_ERR("\t-C\tdisable cache\n");
+	PRINTF_ERR("\t-l\tlock-file\n");
+	PRINTF_ERR("\t-o\tset start offset for disk-file/drive in bytes\n");
+	PRINTF_ERR("\t-s\tset pseudo-disk size in KB\n");
+	PRINTF_ERR("\t-n\tset max. number of pseudo-disks per disk-file/drive\n");
+	PRINTF_ERR("\t-c\tCD-ROM drive\n");
+	PRINTF_ERR("\t-p\tphysical drive\n");
+	PRINTF_ERR("\t-f\tfloppy drive or disk-file\n");
+	PRINTF_ERR("\t\t<floppy-drive> = floppyla: | floppylb: | floppyha: | floppyhb:\n");
+#elif defined(__CYGWIN__)
+	PRINTF_ERR("usage: %s [-h] [-r] [-F] [-C] [-l <lock-file>] [-o <start-offset>] [-s <pseudo-disk-size>] [-n <pseudo-disk-number>] [-c <cdrom-index> ...] [-p <physdrive-index> ...] [[-f] <disk-file> ...]\n",name);
+	PRINTF_ERR("\t-h\tprint this info\n");
+	PRINTF_ERR("\t-r\tread-only mode\n");
+	PRINTF_ERR("\t-F\tdisable floppy filesystem\n");
+	PRINTF_ERR("\t-C\tdisable cache\n");
+	PRINTF_ERR("\t-l\tlock-file\n");
+	PRINTF_ERR("\t-o\tset start offset for disk-file/drive in bytes\n");
+	PRINTF_ERR("\t-s\tset pseudo-disk size in KB\n");
+	PRINTF_ERR("\t-n\tset max. number of pseudo-disks per disk-file/drive\n");
+	PRINTF_ERR("\t-c\tCD-ROM drive\n");
+	PRINTF_ERR("\t-p\tphysical drive\n");
+	PRINTF_ERR("\t-f\tdisk-file\n");
+#else
+	PRINTF_ERR("usage: %s [-h] [-r] [-F] [-C] [-l <lock-file>] [-o <start-offset>] [-s <pseudo-disk-size>] [-n <pseudo-disk-number>] [[-f] <disk-file> ...]\n",name);
+	PRINTF_ERR("\t-h\tprint this info\n");
+	PRINTF_ERR("\t-r\tread-only mode\n");
+	PRINTF_ERR("\t-F\tdisable floppy filesystem\n");
+	PRINTF_ERR("\t-C\tdisable cache\n");
+	PRINTF_ERR("\t-l\tlock-file\n");
+	PRINTF_ERR("\t-o\tset start offset for disk-file/drive in bytes\n");
+	PRINTF_ERR("\t-s\tset pseudo-disk size in KB\n");
+	PRINTF_ERR("\t-n\tset max. number of pseudo-disks per disk-file/drive\n");
+	PRINTF_ERR("\t-f\tdisk-file\n");
+#endif
+}
+
+int
+AKAIUTIL_MAIN(int argc, char **argv)
+{
+	int op;
+	int readonly;
+	int floppyenable;
+#ifdef _VISUALCPP
+	HANDLE lockh;
+	OVERLAPPED lockov;
+#else /* !_VISUALCPP */
+	int lockfd;
+	struct flock lockfl;
+#endif /* !_VISUALCPP */
+	int lockflag;
+	OFF64_T startoff;
+	u_int pseudodisksize;
+	u_int pseudodisknum;
+#define CURWAVNAMEMAXLEN	256 /* XXX */
+	static char curwavname[CURWAVNAMEMAXLEN];
+#define CURWAVCMDBUFSIZ		(CURWAVNAMEMAXLEN+64) /* XXX */
+	static char curwavcmdbuf[CURWAVCMDBUFSIZ];
+	int restartflag;
+	u_int i;
+	U_INT64 j;
+	int mainret;
+
+	PRINTF_OUT("\n"
+			   "****************************************************\n"
+			   "*                                                  *\n"
+			   "*  AKAI S900/S1000/S3000 File Manager, Rev. 4.6.7  *\n"
+			   "*                                                  *\n"
+			   "****************************************************\n"
+			   "\n"
+			   "Copyright (c) 2008-2022 Klaus Michael Indlekofer. All rights reserved.\n"
+			   "\n");
+#ifdef _VISUALCPP
+	PRINTF_OUT("This product uses fdrawcmd.sys developed by Simon Owen.\n"\
+			   "\n"
+			   "This product includes getopt,strncasecmp developed by\n"
+			   "the University of California, Berkeley and its contributors.\n"
+			   "Copyright (c) 1987-2002 The Regents of the University of California.\n"
+			   "All rights reserved.\n"
+			   "\n");
+#endif /* _VISUALCPP */
+	PRINTF_OUT("\n");
+
+	if (argc<=1){
+		usage(argv[0]);
+		AKAIUTIL_EXIT(1);
+	}
+
+	disk_num=0; /* no disks so far */
+	init_blk_cache(); /* init cache */
+	blk_cache_enable=1; /* enable cache */
+#ifdef _VISUALCPP
+	if (fldr_init()<0){
+		mainret=1; /* error */
+		goto main_exit;
+	}
+#endif /* _VISUALCPP */
+
+	/* no current external WAV file so far */
+	curwavname[0]='\0';
+	curwavcmdbuf[0]='\0';
+
+	mainret=0; /* no error so far */
+
+	PRINTF_OUT("opening disks\n");
+
+	/* parse arguments */
+	readonly=0; /* R/W so far */
+	floppyenable=1; /* start with floppy filesystem for disk-files/CD-ROM drives/physical drives allowed */
+#ifdef _VISUALCPP
+	lockh=INVALID_HANDLE_VALUE; /* no lock-file so far */
+	bzero(&lockov,sizeof(OVERLAPPED));
+	lockov.Offset=0; /* XXX offset 0 (lower DWORD) */
+	lockov.OffsetHigh=0; /* XXX offset 0 (upper DWORD) */
+	lockov.hEvent=0;
+#else /* !_VISUALCPP */
+	lockfd=-1; /* no lock-file so far */
+	bzero(&lockfl,sizeof(struct flock));
+	lockfl.l_whence=SEEK_SET;
+	lockfl.l_start=0; /* XXX offset 0 */
+	lockfl.l_len=1; /* XXX 1 byte */
+#endif /* !_VISUALCPP */
+	lockflag=0; /* lock not acquired yet */
+	startoff=0;
+	pseudodisksize=0; /* 0 means: pseudo-disk size is not specified */
+	pseudodisknum=0; /* 0 means: max. number of pseudo-disks is not specified */
+#if defined(_VISUALCPP)||defined(__CYGWIN__)
+#define OPT_STRING "hrFCl:o:s:n:c:p:f:"
+#else
+#define OPT_STRING "hrFCl:o:s:n:f:"
+#endif
+	while ((op=getopt(argc,argv,OPT_STRING))!=EOF){
+		switch (op){
+		case 'h':
+			usage(argv[0]);
+			goto main_exit;
+		case 'r':
+			/* Note: -r option shall affect all disk-files/drives */
+			/* Note: CD-ROM drive are always read-only (see below), independent of -r option */
+			if ((!readonly)&&(disk_num>0)){
+				PRINTF_ERR("\n-r option must be prior to any disk-file/drive arguments\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			readonly=1; /* read-only mode */
+			break;
+		case 'F':
+			/* Note: -F option shall affect all disk-files/drives */
+			if (floppyenable&&(disk_num>0)){
+				PRINTF_ERR("\n-F option must be prior to any disk-file/drive arguments\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			floppyenable=0; /* disable floppy filesystem for disk-files/CD-ROM drives/physical drives */
+			break;
+		case 'C':
+			/* Note: -C option must be prior to any disk I/O */
+			if (blk_cache_enable&&(disk_num>0)){
+				PRINTF_ERR("\n-C option must be prior to any disk-file/drive arguments\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			blk_cache_enable=0; /* disable cache */
+			/* Note: command CMD_ENABLECACHE may enable cache again */
+			break;
+		case 'l':
+			if (lockflag){
+				PRINTF_ERR("\n-l option must not be used multiple times\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			/* Note: -l option must be prior to any disk I/O */
+			if (disk_num>0){
+				PRINTF_ERR("\n-l option must be prior to any disk-file/drive arguments\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+#ifdef _VISUALCPP
+			/* open lock-file */
+			lockh=CreateFileA(optarg,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,OPEN_ALWAYS,0,NULL);
+			if (lockh==INVALID_HANDLE_VALUE){
+				PRINTF_ERR("cannot open lock-file\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			/* acquire lock */
+			if (LockFileEx(lockh,LOCKFILE_EXCLUSIVE_LOCK,0,1,0,&lockov)==FALSE){ /* XXX 1 byte */
+				PRINTF_ERR("cannot acquire lock\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+#else /* !_VISUALCPP */
+			/* open lock-file */
+			if ((lockfd=OPEN(optarg,O_WRONLY|O_CREAT|O_BINARY,0666))<0){
+				PERROR("open lock-file");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			/* acquire lock */
+			lockfl.l_type=F_WRLCK; /* exclusive lock */
+			if (fcntl(lockfd,F_SETLKW,&lockfl)<0){
+				PRINTF_ERR("cannot acquire lock\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+#endif /* !_VISUALCPP */
+			lockflag=1;
+			break;
+		case 'o':
+			if (strncmp(optarg,"0x",2)==0){
+				startoff=(OFF64_T)STRHEX_TO_UINT64(optarg+2);
+			}else{
+				startoff=(OFF64_T)STRDEC_TO_UINT64(optarg);
+			}
+			break;
+		case 's':
+			if (strncmp(optarg,"0x",2)==0){
+				j=STRHEX_TO_UINT64(optarg+2)*1024;
+			}else{
+				j=STRDEC_TO_UINT64(optarg)*1024;
+			}
+			if (j>0xffffffff){ /* XXX 32bit overflow protection */
+				PRINTF_ERR("pseudo-disk size is too large\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			pseudodisksize=(u_int)j;
+			/* Note: pseudodisksize>AKAI_DISKSIZE_MAX is allowed */
+			/* Note: pseudodisksize==0 is allowed and means: pseudo-disk size is not specified */
+			break;
+		case 'n':
+			pseudodisknum=(u_int)atoi(optarg);
+			if (pseudodisknum>PSEUDODISK_NUM_MAX){
+				PRINTF_ERR("max. number of pseudo-disks is too large\n");
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			/* Note: pseudodisknum==0 is allowed and means: max. number of pseudo-disks is not specified */
+			break;
+#if defined(_VISUALCPP)||defined(__CYGWIN__)
+		case 'c':
+			/* open CD-ROM drive */
+			sprintf(dirnamebuf,"\\\\.\\cdrom%i",atoi(optarg));
+			if (open_disk(dirnamebuf,1,startoff,pseudodisksize,pseudodisknum)<0){ /* 1: read-only */
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			break;
+		case 'p':
+			/* open physical drive, Note: use with care!!! */
+			sprintf(dirnamebuf,"\\\\.\\physicaldrive%i",atoi(optarg));
+			if (open_disk(dirnamebuf,readonly,startoff,pseudodisksize,pseudodisknum)<0){
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			break;
+#endif
+		case 'f':
+			/* open floppy drive or disk-file */
+			if (open_disk(optarg,readonly,startoff,pseudodisksize,pseudodisknum)<0){
+				mainret=1; /* error */
+				goto main_exit;
+			}
+			break;
+		case '?':
+			/* fall through */
+		default:
+			mainret=1; /* error */
+			break;
+		}
+	}
+	if ((mainret!=0)||(optind>argc)){
+		usage(argv[0]);
+		mainret=1; /* error */
+		goto main_exit;
+	}
+
+	/* remaining arguments: floppy drives or disk-files */
+	for (;optind<argc;optind++){
+		/* open floppy drive or disk-file */
+		if (open_disk(argv[optind],readonly,startoff,pseudodisksize,pseudodisknum)<0){
+			mainret=1; /* error */
+			goto main_exit;
+		}
+	}
+
+	if (disk_num==0){
+		PRINTF_ERR("no disks\n");
+		mainret=1; /* error */
+		goto main_exit;
+	}
+	PRINTF_OUT("done\n");
+	FLUSH_ALL;
+
+	restartflag=1;
+
+main_restart: /* restart with opened disks */
+	FLUSH_ALL;
+
+	if (blk_cache_enable){ /* cache enabled? */
+		if (flush_blk_cache()<0){
+			/* XXX try once again */
+			PRINTF_ERR("trying again to flush cache\n");
+			FLUSH_ALL;
+			flush_blk_cache(); /* XXX if error, too late */
+		}
+		free_blk_cache();
+	}
+
+	if (restartflag){
+		PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+		/* no current external WAV file */
+		curwavname[0]='\0';
+		curwavcmdbuf[0]='\0';
+		akai_clear_filetag(curfiltertag,AKAI_FILE_TAGFREE); /* clear all filter tags */
+		dirnamebuf[0]='\0'; /* no previous directory given */
+	}
+
+	/* scan disks */
+	if (restartflag){
+		PRINTF_OUT("\nscanning disks\n");
+	}
+	part_num=0; /* no partitions found so far */
+	for (i=0;i<disk_num;i++){
+		if (restartflag){
+			PRINTF_OUT("disk%u\r",i);
+		}
+		FLUSH_ALL;
+#ifdef _VISUALCPP
+		if (disk[i].fldrn>=0){ /* is floppy drive? */
+			/* Note: ignore floppyenable */
+			if (akai_scan_floppy(&disk[i])<0){
+#if 0 /* XXX ignore error */
+				mainret=1; /* error */
+				goto main_exit;
+#endif
+			}
+		}else /* no floppy drive */
+#endif /* _VISUALCPP */
+		{
+			if (akai_scan_disk(&disk[i],floppyenable)<0){
+#if 0 /* XXX ignore error */
+				mainret=1; /* error */
+				goto main_exit;
+#endif
+			}
+		}
+	}
+	if (restartflag){
+		PRINTF_OUT("done        \n");
+	}
+	if (disk_num>=DISK_NUM_MAX){
+		PRINTF_OUT("\nmax. number (%u) of disks reached\n",DISK_NUM_MAX);
+	}
+	if (part_num>=PART_NUM_MAX){
+		PRINTF_OUT("\nmax. number (%u) of partitions reached\n",PART_NUM_MAX);
+	}
+
+	if (restartflag){
+		/* print disks */
+		PRINTF_OUT("\n");
+		akai_list_alldisks(0,NULL);
+		FLUSH_ALL;
+	}
+
+	/* set current directory */
+	/* Note: upon (re)start, dirnamebuf[] contains path of previous directory (or '\0' if none) */
+	if (dirnamebuf[0]!='\0'){ /* previous directory given? */
+		if (change_curdir(dirnamebuf,0,NULL,1)<0){ /* NULL,1: check last */
+			PRINTF_ERR("\nprevious directory not found\n");
+			FLUSH_ALL;
+			dirnamebuf[0]='\0'; /* no previous directory given anymore */
+		}
+	}
+	if (dirnamebuf[0]=='\0'){ /* no previous directory given? */
+		change_curdir_home(); /* XXX ignore error */
+	}
+
+	/* command interpreter */
+	{
+#define CMDLEN 256 /* XXX */
+		char cmd[CMDLEN+1]; /* +1 for '\0' */
+#define CMDTOKMAX 16
+		char *(cmdtok[CMDTOKMAX]);
+		int cmdtoknr;
+		int i;
+		char *p;
+
+		enum cmd_e{
+			CMD_HELP,
+			CMD_EXIT,
+			CMD_RESTART,
+			CMD_RESTARTKEEP,
+			CMD_DINFO,
+			CMD_DF,
+			CMD_CD,
+			CMD_CDI,
+			CMD_DIR,
+			CMD_DIRREC,
+			CMD_LSTAGS,
+			CMD_INITTAGS,
+			CMD_RENTAG,
+			CMD_CDINFO,
+			CMD_VCDINFO,
+			CMD_SETCDINFO,
+			CMD_LCD,
+			CMD_LDIR,
+			CMD_LSFAT,
+			CMD_LSFATI,
+			CMD_LSTFATI,
+			CMD_INFOI,
+			CMD_INFOALL,
+			CMD_TINFOI,
+			CMD_TINFOALL,
+			CMD_DEL,
+			CMD_DELI,
+			CMD_TDELI,
+			CMD_REN,
+			CMD_RENI,
+			CMD_SETOSVERI,
+			CMD_SETOSVERALL,
+			CMD_SETUNCOMPRI,
+			CMD_UPDATEUNCOMPRI,
+			CMD_UPDATEUNCOMPRALL,
+			CMD_SAMPLE900UNCOMPR,
+			CMD_SAMPLE900UNCOMPRI,
+			CMD_SAMPLE900UNCOMPRALL,
+			CMD_SAMPLE900COMPR,
+			CMD_SAMPLE900COMPRI,
+			CMD_SAMPLE900COMPRALL,
+			CMD_FIXRAMNAME,
+			CMD_FIXRAMNAMEI,
+			CMD_FIXRAMNAMEALL,
+			CMD_CLRTAGI,
+			CMD_CLRTAGALL,
+			CMD_SETTAGI,
+			CMD_SETTAGALL,
+			CMD_TRENI,
+			CMD_CLRFILTERTAG,
+			CMD_SETFILTERTAG,
+			CMD_COPY,
+			CMD_COPYI,
+			CMD_COPYVOL,
+			CMD_COPYVOLI,
+			CMD_COPYPART,
+			CMD_COPYTAGS,
+			CMD_WIPEVOL,
+			CMD_WIPEVOLI,
+			CMD_DELVOL,
+			CMD_DELVOLI,
+			CMD_FORMATFLOPPYL9,
+			CMD_FORMATFLOPPYL1,
+			CMD_FORMATFLOPPYL3,
+			CMD_FORMATFLOPPYH9,
+			CMD_FORMATFLOPPYH1,
+			CMD_FORMATFLOPPYH3,
+			CMD_WIPEFLOPPY,
+			CMD_FORMATHARDDISK9,
+			CMD_FORMATHARDDISK1,
+			CMD_FORMATHARDDISK3,
+			CMD_FORMATHARDDISK3CD,
+			CMD_WIPEPART,
+			CMD_WIPEPART3CD,
+			CMD_FIXPART,
+			CMD_FIXHARDDISK,
+			CMD_SCANBADBLKSPART,
+			CMD_MARKBADBLKSPART,
+			CMD_SCANBADBLKSDISK,
+			CMD_MARKBADBLKSDISK,
+			CMD_GETDISK,
+			CMD_PUTDISK,
+			CMD_GETPART,
+			CMD_PUTPART,
+			CMD_GETTAGS,
+			CMD_PUTTAGS,
+			CMD_GETVOLPARAM,
+			CMD_PUTVOLPARAM,
+			CMD_RENVOL,
+			CMD_RENVOLI,
+			CMD_SETOSVERVOL,
+			CMD_SETOSVERVOLI,
+			CMD_SETLNUM,
+			CMD_SETLNUMI,
+			CMD_LSPARAM,
+			CMD_LSPARAMI,
+			CMD_INITPARAM,
+			CMD_INITPARAMI,
+			CMD_SETPARAM,
+			CMD_SETPARAMI,
+			CMD_GETPARAM,
+			CMD_GETPARAMI,
+			CMD_PUTPARAM,
+			CMD_PUTPARAMI,
+			CMD_GET,
+			CMD_GETI,
+			CMD_GETALL,
+			CMD_SAMPLE2WAV,
+			CMD_SAMPLE2WAVI,
+			CMD_SAMPLE2WAVALL,
+			CMD_PUT,
+			CMD_WAV2SAMPLE,
+			CMD_WAV2SAMPLE9,
+			CMD_WAV2SAMPLE9C,
+			CMD_WAV2SAMPLE1,
+			CMD_WAV2SAMPLE3,
+			CMD_TGETI,
+			CMD_TGETALL,
+			CMD_TAKE2WAVI,
+			CMD_TAKE2WAVALL,
+			CMD_TPUT,
+			CMD_WAV2TAKE,
+			CMD_TARC,
+			CMD_TARCWAV,
+			CMD_TARX,
+			CMD_TARX9,
+			CMD_TARX1,
+			CMD_TARX3,
+			CMD_TARX3CD,
+			CMD_TARXWAV,
+			CMD_TARXWAV9,
+			CMD_TARXWAV9C,
+			CMD_TARXWAV1,
+			CMD_TARXWAV3,
+			CMD_MKVOL,
+			CMD_MKVOL9,
+			CMD_MKVOL1,
+			CMD_MKVOL3,
+			CMD_MKVOL3CD,
+			CMD_MKVOLI,
+			CMD_MKVOLI9,
+			CMD_MKVOLI1,
+			CMD_MKVOLI3,
+			CMD_MKVOLI3CD,
+			CMD_DIRCACHE,
+			CMD_DISABLECACHE,
+			CMD_ENABLECACHE,
+			CMD_LOCK,
+			CMD_UNLOCK,
+			CMD_PLAYWAV,
+			CMD_STOPWAV,
+			CMD_DELWAV,
+			CMD_NULL
+		};
+		enum cmd_e cmdnr;
+
+		struct cmdtab_s{
+			enum cmd_e cmdnr;
+			char *cmdstr;
+			int cmdtokmin;
+			int cmdtokmax;
+			char *cmduse;
+			char *cmdhelp;
+		}cmdtab[]={
+			{CMD_HELP,"help",1,2,"[<cmd>]","print help information for a command"},
+			{CMD_HELP,"man",1,2,NULL,NULL},
+			{CMD_EXIT,"exit",1,1,"","exit program"},
+			{CMD_EXIT,"quit",1,1,NULL,NULL},
+			{CMD_EXIT,"bye",1,1,NULL,NULL},
+			{CMD_EXIT,"q",1,1,NULL,NULL},
+			{CMD_RESTART,"restart",1,1,"","restart program (with opened disks)"},
+			{CMD_RESTARTKEEP,"restartkeep",1,1,"","restart program (with opened disks, keep current directory path etc.)"},
+			{CMD_RESTARTKEEP,"restart.",1,1,NULL,NULL},
+			{CMD_RESTARTKEEP,"sync",1,1,NULL,NULL},
+			{CMD_DF,"df",1,1,"","print disk info"},
+			{CMD_DINFO,"dinfo",1,1,"","print current directory info"},
+			{CMD_DINFO,"pwd",1,1,NULL,NULL},
+			{CMD_CD,"cd",1,2,"[<path>]","change current directory"},
+			{CMD_CDI,"cdi",2,2,"<volume-index>","change current volume"},
+			{CMD_DIR,"dir",1,2,"[<path>]","list directory"},
+			{CMD_DIR,"ls",1,2,NULL,NULL},
+			{CMD_DIRREC,"dirrec",1,1,"","list current directory recursively"},
+			{CMD_DIRREC,"lsrec",1,1,NULL,NULL},
+			{CMD_LSTAGS,"lstags",1,1,"","list tags in partition"},
+			{CMD_LSTAGS,"dirtags",1,1,NULL,NULL},
+			{CMD_INITTAGS,"inittags",1,1,"","initialize tags of disk or partition"},
+			{CMD_RENTAG,"rentag",3,3,"<tag-index> <tag-name>","rename tag in partition"},
+			{CMD_CDINFO,"cdinfo",1,1,"","print CD3000 CD-ROM info"},
+			{CMD_VCDINFO,"vcdinfo",1,1,"","print verbose CD3000 CD-ROM info"},
+			{CMD_SETCDINFO,"setcdinfo",1,2,"[<cdlabel>]","set CD3000 CD-ROM info of disk or partition"},
+			{CMD_LCD,"lcd",2,2,"<dir-path>","change current local (external) directory"},
+			{CMD_LDIR,"ldir",1,1,"","list files in current local (external) directory"},
+			{CMD_LDIR,"lls",1,1,NULL,NULL},
+			{CMD_LSFAT,"lsfat",1,1,"","list FAT of partition"},
+			{CMD_LSFATI,"lsfati",2,2,"<file-index>","print FAT-chain of file"},
+			{CMD_LSTFATI,"lstfati",2,2,"<take-index>","print FAT-chain of DD take"},
+			{CMD_INFOI,"infoi",2,2,"<file-index>","print information for file"},
+			{CMD_INFOALL,"infoall",1,1,"","print information for all files in current volume"},
+			{CMD_TINFOI,"tinfoi",2,2,"<take-index>","print information for DD take"},
+			{CMD_TINFOALL,"tinfoall",1,1,"","print information for all DD takes in current partition"},
+			{CMD_DEL,"del",2,2,"<file-path>","delete file"},
+			{CMD_DEL,"rm",2,2,NULL,NULL},
+			{CMD_DELI,"deli",2,2,"<file-index>","delete file"},
+			{CMD_DELI,"rmi",2,2,NULL,NULL},
+			{CMD_TDELI,"tdeli",2,2,"<take-index>","delete DD take"},
+			{CMD_TDELI,"trmi",2,2,NULL,NULL},
+			{CMD_REN,"ren",3,4,"<old-file-path> <new-file-path> [<new-file-index>]","rename/move file"},
+			{CMD_REN,"mv",3,4,NULL,NULL},
+			{CMD_RENI,"reni",3,4,"<old-file-index> <new-file-path> [<new-file-index>]","rename/move file"},
+			{CMD_RENI,"mvi",3,4,NULL,NULL},
+			{CMD_SETOSVERI,"setosveri",3,3,"<file-index> <new-os-version>","set OS version of file in S1000/S3000 volume"},
+			{CMD_SETOSVERALL,"setosverall",2,2,"<new-os-version>","set OS version of all files in current S1000/S3000 volume"},
+			{CMD_SETUNCOMPRI,"setuncompri",3,3,"<file-index> <new-uncompr>","set uncompr value of compressed file in S900 volume"},
+			{CMD_UPDATEUNCOMPRI,"updateuncompri",2,2,"<file-index>","update uncompr value of compressed file in S900 volume"},
+			{CMD_UPDATEUNCOMPRALL,"updateuncomprall",1,1,"","update uncompr value of all compressed files in current S900 volume"},
+			{CMD_SAMPLE900UNCOMPR,"sample900uncompr",2,3,"<file-path> [<dest-vol-path>]","uncompress S900 compressed sample file"},
+			{CMD_SAMPLE900UNCOMPR,"s9uncompr",2,3,NULL,NULL},
+			{CMD_SAMPLE900UNCOMPRI,"sample900uncompri",2,3,"<file-index> [<dest-vol-path>]","uncompress S900 compressed sample file"},
+			{CMD_SAMPLE900UNCOMPRI,"s9uncompri",2,3,NULL,NULL},
+			{CMD_SAMPLE900UNCOMPRALL,"sample900uncomprall",1,2,"[<dest-vol-path>]","uncompress all S900 compressed sample files in current volume"},
+			{CMD_SAMPLE900UNCOMPRALL,"s9uncomprall",1,2,NULL,NULL},
+			{CMD_SAMPLE900COMPR,"sample900compr",2,3,"<file-path> [<dest-vol-path>]","compress S900 non-compressed sample file"},
+			{CMD_SAMPLE900COMPR,"s9compr",2,3,NULL,NULL},
+			{CMD_SAMPLE900COMPRI,"sample900compri",2,3,"<file-index> [<dest-vol-path>]","compress S900 non-compressed sample file"},
+			{CMD_SAMPLE900COMPRI,"s9compri",2,3,NULL,NULL},
+			{CMD_SAMPLE900COMPRALL,"sample900comprall",1,2,"[<dest-vol-path>]","compress all S900 non-compressed sample files in current volume"},
+			{CMD_SAMPLE900COMPRALL,"s9comprall",1,2,NULL,NULL},
+			{CMD_FIXRAMNAME,"fixramname",2,2,"<file-path>","fix name in file header"},
+			{CMD_FIXRAMNAMEI,"fixramnamei",2,2,"<file-index>","fix name in file header"},
+			{CMD_FIXRAMNAMEALL,"fixramnameall",1,1,"","fix name in file header of all files in current volume"},
+			{CMD_CLRTAGI,"clrtagi",3,3,"<file-index> {<tag-index>|all}","untag file"},
+			{CMD_CLRTAGALL,"clrtagall",2,2,"{<tag-index>|all}","untag all files in current volume"},
+			{CMD_SETTAGI,"settagi",3,3,"<file-index> <tag-index>","tag file"},
+			{CMD_SETTAGALL,"settagall",2,2,"<tag-index>","tag all files in current volume"},
+			{CMD_TRENI,"treni",3,3,"<take-index> <new-name>","rename DD take"},
+			{CMD_TRENI,"tmvi",3,3,NULL,NULL},
+			{CMD_CLRFILTERTAG,"clrfiltertag",2,2,"{<tag-index>|all}","remove tag from file filter"},
+			{CMD_SETFILTERTAG,"setfiltertag",2,2,"<tag-index>","add tag to file filter"},
+			{CMD_COPY,"copy",3,4,"<src-file-path> <new-file-path> [<new-file-index>]","copy file"},
+			{CMD_COPY,"cp",3,4,NULL,NULL},
+			{CMD_COPYI,"copyi",3,4,"<src-file-index> <new-file-path> [<new-file-index>]","copy file"},
+			{CMD_COPYI,"cpi",3,4,NULL,NULL},
+			{CMD_COPYVOL,"copyvol",3,3,"<src-volume-path> <new-volume-path>","copy volume (with all of its files)"},
+			{CMD_COPYVOL,"cpvol",3,3,NULL,NULL},
+			{CMD_COPYVOLI,"copyvoli",3,3,"<src-volume-index> <new-volume-path>","copy volume (with all of its files)"},
+			{CMD_COPYVOLI,"cpvoli",3,3,NULL,NULL},
+			{CMD_COPYPART,"copypart",3,3,"<src-partition-path> <dst-partition-path>","copy all volumes of a partition"},
+			{CMD_COPYPART,"cppart",3,3,NULL,NULL},
+			{CMD_COPYTAGS,"copytags",3,3,"<src-partition-path> <dst-partition-path>","copy all tags of a partition"},
+			{CMD_COPYTAGS,"cptags",3,3,NULL,NULL},
+			{CMD_WIPEVOL,"wipevol",2,2,"<volume-path>","delete all files in volume"},
+			{CMD_WIPEVOL,"wipedir",2,2,NULL,NULL},
+			{CMD_WIPEVOL,"rmall",2,2,NULL,NULL},
+			{CMD_WIPEVOLI,"wipevoli",2,2,"<volume-index>","delete all files in volume"},
+			{CMD_WIPEVOLI,"wipediri",2,2,NULL,NULL},
+			{CMD_WIPEVOLI,"rmalli",2,2,NULL,NULL},
+			{CMD_DELVOL,"delvol",2,2,"<volume-path>","delete volume and all of its files"},
+			{CMD_DELVOL,"deldir",2,2,NULL,NULL},
+			{CMD_DELVOL,"rmvol",2,2,NULL,NULL},
+			{CMD_DELVOL,"rmdir",2,2,NULL,NULL},
+			{CMD_DELVOLI,"delvoli",2,2,"<volume-index>","delete volume and all of its files"},
+			{CMD_DELVOLI,"deldiri",2,2,NULL,NULL},
+			{CMD_DELVOLI,"rmvoli",2,2,NULL,NULL},
+			{CMD_DELVOLI,"rmdiri",2,2,NULL,NULL},
+			{CMD_FORMATFLOPPYL9,"formatfloppyl9",1,1,"","format/erase low-density floppy for S900/S950, create filesystem"},
+			{CMD_FORMATFLOPPYL9,"formatfl9",1,1,NULL,NULL},
+			{CMD_FORMATFLOPPYL1,"formatfloppyl1",1,1,"","format/erase low-density floppy for S1000, create filesystem"},
+			{CMD_FORMATFLOPPYL1,"formatfl1",1,1,NULL,NULL},
+			{CMD_FORMATFLOPPYL3,"formatfloppyl3",1,1,"","format/erase low-density floppy for S3000, create filesystem"},
+			{CMD_FORMATFLOPPYL3,"formatfl3",1,1,NULL,NULL},
+			{CMD_FORMATFLOPPYH9,"formatfloppyh9",1,1,"","format/erase high-density floppy for S950, create filesystem"},
+			{CMD_FORMATFLOPPYH9,"formatfh9",1,1,NULL,NULL},
+			{CMD_FORMATFLOPPYH1,"formatfloppyh1",1,1,"","format/erase high-density floppy for S1000, create filesystem"},
+			{CMD_FORMATFLOPPYH1,"formatfh1",1,1,NULL,NULL},
+			{CMD_FORMATFLOPPYH3,"formatfloppyh3",1,1,"","format/erase high-density floppy for S3000, create filesystem"},
+			{CMD_FORMATFLOPPYH3,"formatfh3",1,1,NULL,NULL},
+			{CMD_WIPEFLOPPY,"wipefloppy",1,1,"","create filesystem on floppy"},
+			{CMD_WIPEFLOPPY,"newfsfloppy",1,1,NULL,NULL},
+			{CMD_FORMATHARDDISK9,"formatharddisk9",1,2,"[<total-size>[M]|SH205|SUPRA20M|SUPRA30M|SUPRA60M]","create filesystem on harddisk for S900/S950 (size in blocks or MB, or drive name)"},
+			{CMD_FORMATHARDDISK9,"formathd9",1,2,NULL,NULL},
+			{CMD_FORMATHARDDISK9,"newfsharddisk9",1,2,NULL,NULL},
+			{CMD_FORMATHARDDISK9,"newfshd9",1,2,NULL,NULL},
+			{CMD_FORMATHARDDISK1,"formatharddisk1",1,3,"[<part-size>[M] [<total-size>[M]]]","create filesystem on harddisk for S1000 (size in blocks or MB)"},
+			{CMD_FORMATHARDDISK1,"formathd1",1,3,NULL,NULL},
+			{CMD_FORMATHARDDISK1,"newfsharddisk1",1,3,NULL,NULL},
+			{CMD_FORMATHARDDISK1,"newfshd1",1,3,NULL,NULL},
+			{CMD_FORMATHARDDISK3,"formatharddisk3",1,3,"[<part-size>[M] [<total-size>[M]]]","create filesystem on harddisk for S3000 or CD3000 (size in blocks or MB)"},
+			{CMD_FORMATHARDDISK3,"formathd3",1,3,NULL,NULL},
+			{CMD_FORMATHARDDISK3,"newfsharddisk3",1,3,NULL,NULL},
+			{CMD_FORMATHARDDISK3,"newfshd3",1,3,NULL,NULL},
+			{CMD_FORMATHARDDISK3CD,"formatharddisk3cd",1,3,"[<part-size>[M] [<total-size>[M]]]","create filesystem on harddisk for CD3000 CD-ROM (size in blocks or MB)"},
+			{CMD_FORMATHARDDISK3CD,"formatcd",1,3,NULL,NULL},
+			{CMD_FORMATHARDDISK3CD,"newfsharddisk3cd",1,3,NULL,NULL},
+			{CMD_FORMATHARDDISK3CD,"newfscd",1,3,NULL,NULL},
+			{CMD_WIPEPART,"wipepart",1,2,"[<partition-path>]","create filesystem in harddisk partition"},
+			{CMD_WIPEPART,"newfspart",1,2,NULL,NULL},
+			{CMD_WIPEPART3CD,"wipepart3cd",1,2,"[<partition-path>]","create filesystem in harddisk partition for CD3000 CD-ROM"},
+			{CMD_WIPEPART3CD,"newfspart3cd",1,2,NULL,NULL},
+			{CMD_FIXPART,"fixpart",1,2,"[<partition-path>]","fix filesystem in harddisk partition"},
+			{CMD_FIXHARDDISK,"fixharddisk",1,2,"[<disk-path>]","fix filesystem on harddisk"},
+			{CMD_SCANBADBLKSPART,"scanbadblkspart",1,2,"[<partition-path>]","scan for bad blocks/clusters in partition"},
+			{CMD_MARKBADBLKSPART,"markbadblkspart",1,2,"[<partition-path>]","mark free bad blocks/clusters in partition"},
+			{CMD_SCANBADBLKSDISK,"scanbadblksdisk",1,2,"[<disk-path>]","scan for bad blocks/clusters in all partitions of disk"},
+			{CMD_MARKBADBLKSDISK,"markbadblksdisk",1,2,"[<disk-path>]","mark free bad blocks/clusters in all partitions of disk"},
+			{CMD_GETDISK,"getdisk",2,2,"<file-name>","get disk (to external file)"},
+			{CMD_GETDISK,"dget",2,2,NULL,NULL},
+			{CMD_GETDISK,"dexport",2,2,NULL,NULL},
+			{CMD_PUTDISK,"putdisk",2,2,"<file-name>","put disk (from external file)"},
+			{CMD_PUTDISK,"dput",2,2,NULL,NULL},
+			{CMD_PUTDISK,"dimport",2,2,NULL,NULL},
+			{CMD_GETPART,"getpart",2,3,"[<partition-path>] <file-name>","get partition (to external file)"},
+			{CMD_GETPART,"pget",2,3,NULL,NULL},
+			{CMD_GETPART,"pexport",2,3,NULL,NULL},
+			{CMD_PUTPART,"putpart",2,3,"<file-name> [<partition-path>]","put partition (from external file)"},
+			{CMD_PUTPART,"pput",2,3,NULL,NULL},
+			{CMD_PUTPART,"pimport",2,3,NULL,NULL},
+			{CMD_GETTAGS,"gettags",2,2,"<file-name>","get tags from partition (to external file)"},
+			{CMD_GETTAGS,"tagsget",2,2,NULL,NULL},
+			{CMD_GETTAGS,"tagsexport",2,2,NULL,NULL},
+			{CMD_PUTTAGS,"puttags",2,2,"<file-name>","put tags to partition (from external file)"},
+			{CMD_PUTTAGS,"tagsput",2,2,NULL,NULL},
+			{CMD_PUTTAGS,"tagsimport",2,2,NULL,NULL},
+			{CMD_RENVOL,"renvol",3,3,"<old-path> <new-name>","rename volume"},
+			{CMD_RENVOL,"rendir",3,3,NULL,NULL},
+			{CMD_RENVOL,"mvvol",3,3,NULL,NULL},
+			{CMD_RENVOL,"mvdir",3,3,NULL,NULL},
+			{CMD_RENVOLI,"renvoli",3,3,"<volume-index> <new-name>","rename volume"},
+			{CMD_RENVOLI,"rendiri",3,3,NULL,NULL},
+			{CMD_RENVOLI,"mvvoli",3,3,NULL,NULL},
+			{CMD_RENVOLI,"mvdiri",3,3,NULL,NULL},
+			{CMD_SETOSVERVOL,"setosvervol",2,2,"<new-os-version>","set OS version of current volume"},
+			{CMD_SETOSVERVOLI,"setosvervoli",3,3,"<volume-index> <new-os-version>","set OS version of volume"},
+			{CMD_SETLNUM,"setlnum",2,2,"<new-load-number>","set load number of current volume (OFF for none)"},
+			{CMD_SETLNUMI,"setlnumi",3,3,"<volume-index> <new-load-number>","set load number of volume (OFF for none)"},
+			{CMD_LSPARAM,"lsparam",1,1,"","list parameters in current volume"},
+			{CMD_LSPARAMI,"lsparami",2,2,"<volume-index>","list parameters in volume"},
+			{CMD_INITPARAM,"initparam",1,1,"","initialize parameters in current volume"},
+			{CMD_INITPARAMI,"initparami",2,2,"<volume-index>","initialize parameters in volume"},
+			{CMD_SETPARAM,"setparam",3,3,"<par-index> <par-value>","set parameters in current volume"},
+			{CMD_SETPARAMI,"setparami",4,4,"<volume-index> <par-index> <par-value>","set parameters in volume"},
+			{CMD_GETPARAM,"getparam",2,2,"<file-name>","get parameters from current volume (to external file)"},
+			{CMD_GETPARAM,"paramget",2,2,NULL,NULL},
+			{CMD_GETPARAM,"paramexport",2,2,NULL,NULL},
+			{CMD_GETPARAMI,"getparami",3,3,"<volume-index> <file-name>","get parameters from volume (to external file)"},
+			{CMD_GETPARAMI,"paramgeti",3,3,NULL,NULL},
+			{CMD_GETPARAMI,"paramexporti",3,3,NULL,NULL},
+			{CMD_PUTPARAM,"putparam",2,2,"<file-name>","put parameters to current volume (from external file)"},
+			{CMD_PUTPARAM,"paramput",2,2,NULL,NULL},
+			{CMD_PUTPARAM,"paramimport",2,2,NULL,NULL},
+			{CMD_PUTPARAMI,"putparami",3,3,"<volume-index> <file-name>","put parameters to volume (from external file)"},
+			{CMD_PUTPARAMI,"paramputi",3,3,NULL,NULL},
+			{CMD_PUTPARAMI,"paramimporti",3,3,NULL,NULL},
+			{CMD_GET,"get",2,4,"<file-path> [<begin-byte> [<end-byte>]]","get file (to external)"},
+			{CMD_GET,"export",2,4,NULL,NULL},
+			{CMD_GETI,"geti",2,4,"<file-index> [<begin-byte> [<end-byte>]]","get file (to external)"},
+			{CMD_GETI,"exporti",2,4,NULL,NULL},
+			{CMD_GETALL,"getall",1,1,"","get all files (to external)"},
+			{CMD_GETALL,"exportall",1,1,NULL,NULL},
+			{CMD_SAMPLE2WAV,"sample2wav",2,2,"<file-path>","convert sample file into external WAV file"},
+			{CMD_SAMPLE2WAV,"s2wav",2,2,NULL,NULL},
+			{CMD_SAMPLE2WAV,"getwav",2,2,NULL,NULL},
+			{CMD_SAMPLE2WAVI,"sample2wavi",2,2,"<file-index>","convert sample file into external WAV file"},
+			{CMD_SAMPLE2WAVI,"s2wavi",2,2,NULL,NULL},
+			{CMD_SAMPLE2WAVI,"getwavi",2,2,NULL,NULL},
+			{CMD_SAMPLE2WAVALL,"sample2wavall",1,1,NULL,"convert all sample files into external WAV files"},
+			{CMD_SAMPLE2WAVALL,"s2wavall",1,1,NULL,NULL},
+			{CMD_SAMPLE2WAVALL,"getwavall",1,1,NULL,NULL},
+			{CMD_PUT,"put",2,3,"[<volume-path>/]<file-name> [<file-index>]","put file (from external, use * for all local files)"},
+			{CMD_PUT,"import",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE,"wav2sample",2,3,"[<volume-path>/]<wav-file> [<file-index>]","convert external WAV file into sample file (use *.wav for all local WAV files)"},
+			{CMD_WAV2SAMPLE,"wav2s",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE,"putwav",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE9,"wav2sample9",2,3,"[<volume-path>/]<wav-file> [<file-index>]","convert external WAV file into S900 non-compressed sample file (use *.wav for all local WAV files)"},
+			{CMD_WAV2SAMPLE9,"wav2s9",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE9,"putwav9",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE9C,"wav2sample9c",2,3,"[<volume-path>/]<wav-file> [<file-index>]","convert external WAV file into S900 compressed sample file (use *.wav for all local WAV files)"},
+			{CMD_WAV2SAMPLE9C,"wav2s9c",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE9C,"putwav9c",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE1,"wav2sample1",2,3,"[<volume-path>/]<wav-file> [<file-index>]","convert external WAV file into S1000 sample file (use *.wav for all local WAV files)"},
+			{CMD_WAV2SAMPLE1,"wav2s1",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE1,"putwav1",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE3,"wav2sample3",2,3,"[<volume-path>/]<wav-file> [<file-index>]","convert external WAV file into S3000 sample file (use *.wav for all local WAV files)"},
+			{CMD_WAV2SAMPLE3,"wav2s3",2,3,NULL,NULL},
+			{CMD_WAV2SAMPLE3,"putwav3",2,3,NULL,NULL},
+			{CMD_TGETI,"tgeti",2,2,"<take-index>","get DD take (to external)"},
+			{CMD_TGETI,"texporti",2,2,NULL,NULL},
+			{CMD_TGETALL,"tgetall",1,1,"","get all DD takes (to external)"},
+			{CMD_TGETALL,"texportall",1,1,NULL,NULL},
+			{CMD_TAKE2WAVI,"take2wavi",2,2,"<take-index>","convert DD take into external WAV file"},
+			{CMD_TAKE2WAVI,"t2wavi",2,2,NULL,NULL},
+			{CMD_TAKE2WAVI,"tgetwavi",2,2,NULL,NULL},
+			{CMD_TAKE2WAVI,"getwavti",2,2,NULL,NULL},
+			{CMD_TAKE2WAVALL,"take2wavall",1,1,NULL,"convert all DD takes into external WAV files"},
+			{CMD_TAKE2WAVALL,"t2wavall",1,1,NULL,NULL},
+			{CMD_TAKE2WAVALL,"tgetwavall",1,1,NULL,NULL},
+			{CMD_TAKE2WAVALL,"getwavtall",1,1,NULL,NULL},
+			{CMD_TPUT,"tput",2,2,"<take-file>","put DD take (from external, use *"AKAI_DDTAKE_FNAMEEND" for all local DD take files)"},
+			{CMD_TPUT,"timport",2,2,NULL,NULL},
+			{CMD_WAV2TAKE,"wav2take",2,2,"<wav-file>","convert external WAV file into DD take (use *.wav for all local WAV files)"},
+			{CMD_WAV2TAKE,"wav2t",2,2,NULL,NULL},
+			{CMD_WAV2TAKE,"tputwav",2,2,NULL,NULL},
+			{CMD_WAV2TAKE,"putwavt",2,2,NULL,NULL},
+			{CMD_TARC,"tarc",2,2,"<tar-file>","tar c from current directory (to external)"},
+			{CMD_TARC,"target",2,2,NULL,NULL},
+			{CMD_TARC,"gettar",2,2,NULL,NULL},
+			{CMD_TARCWAV,"tarcwav",2,2,"<tar-file>","tar c from current directory (to external) with WAV conversion"},
+			{CMD_TARCWAV,"targetwav",2,2,NULL,NULL},
+			{CMD_TARCWAV,"gettarwav",2,2,NULL,NULL},
+			{CMD_TARX,"tarx",2,2,"<tar-file>","tar x in current directory (from external)"},
+			{CMD_TARX,"tarput",2,2,NULL,NULL},
+			{CMD_TARX,"puttar",2,2,NULL,NULL},
+			{CMD_TARX9,"tarx9",2,2,"<tar-file>","tar x in current directory (from external) for S900"},
+			{CMD_TARX9,"tarput9",2,2,NULL,NULL},
+			{CMD_TARX9,"puttar9",2,2,NULL,NULL},
+			{CMD_TARX1,"tarx1",2,2,"<tar-file>","tar x in current directory (from external) for S1000"},
+			{CMD_TARX1,"tarput1",2,2,NULL,NULL},
+			{CMD_TARX1,"puttar1",2,2,NULL,NULL},
+			{CMD_TARX3,"tarx3",2,2,"<tar-file>","tar x in current directory (from external) for S3000 or CD3000"},
+			{CMD_TARX3,"tarput3",2,2,NULL,NULL},
+			{CMD_TARX3,"puttar3",2,2,NULL,NULL},
+			{CMD_TARX3CD,"tarx3cd",2,2,"<tar-file>","tar x in current directory (from external) for CD3000 CD-ROM"},
+			{CMD_TARX3CD,"tarput3cd",2,2,NULL,NULL},
+			{CMD_TARX3CD,"puttar3cd",2,2,NULL,NULL},
+			{CMD_TARXWAV,"tarxwav",2,2,"<tar-file>","tar x in current directory (from external) with WAV conversion"},
+			{CMD_TARXWAV,"tarputwav",2,2,NULL,NULL},
+			{CMD_TARXWAV,"puttarwav",2,2,NULL,NULL},
+			{CMD_TARXWAV9,"tarxwav9",2,2,"<tar-file>","tar x in current directory (from external) with WAV conversion to S900 compressed sample"},
+			{CMD_TARXWAV9,"tarputwav9",2,2,NULL,NULL},
+			{CMD_TARXWAV9,"puttarwav9",2,2,NULL,NULL},
+			{CMD_TARXWAV9C,"tarxwav9c",2,2,"<tar-file>","tar x in current directory (from external) with WAV conversion to S900 compressed sample"},
+			{CMD_TARXWAV9C,"tarputwav9c",2,2,NULL,NULL},
+			{CMD_TARXWAV9C,"puttarwav9c",2,2,NULL,NULL},
+			{CMD_TARXWAV1,"tarxwav1",2,2,"<tar-file>","tar x in current directory (from external) with WAV conversion to S1000 sample"},
+			{CMD_TARXWAV1,"tarputwav1",2,2,NULL,NULL},
+			{CMD_TARXWAV1,"puttarwav1",2,2,NULL,NULL},
+			{CMD_TARXWAV3,"tarxwav3",2,2,"<tar-file>","tar x in current directory (from external) with WAV conversion to S3000 sample"},
+			{CMD_TARXWAV3,"tarputwav3",2,2,NULL,NULL},
+			{CMD_TARXWAV3,"puttarwav3",2,2,NULL,NULL},
+			{CMD_MKVOL,"mkvol",1,2,"[<volume-path>]","create new volume"},
+			{CMD_MKVOL,"mkdir",1,2,NULL,NULL},
+			{CMD_MKVOL9,"mkvol9",1,2,"[<volume-path>]","create new volume for S900"},
+			{CMD_MKVOL9,"mkdir9",1,2,NULL,NULL},
+			{CMD_MKVOL1,"mkvol1",1,3,"[<volume-path> [<load-number>]]","create new volume for S1000"},
+			{CMD_MKVOL1,"mkdir1",1,3,NULL,NULL},
+			{CMD_MKVOL3,"mkvol3",1,3,"[<volume-path> [<load-number>]]","create new volume for S3000 or CD3000"},
+			{CMD_MKVOL3,"mkdir3",1,3,NULL,NULL},
+			{CMD_MKVOL3CD,"mkvol3cd",1,3,"[<volume-path> [<load-number>]]","create new volume for CD3000 CD-ROM"},
+			{CMD_MKVOL3CD,"mkdir3cd",1,3,NULL,NULL},
+			{CMD_MKVOLI,"mkvoli",2,3,"<volume-index> [<volume-name>]","create new volume at index"},
+			{CMD_MKVOLI,"mkdiri",2,3,NULL,NULL},
+			{CMD_MKVOLI9,"mkvoli9",2,3,"<volume-index> [<volume-name>]","create new volume for S900 at index"},
+			{CMD_MKVOLI9,"mkdiri9",2,3,NULL,NULL},
+			{CMD_MKVOLI1,"mkvoli1",2,4,"<volume-index> [<volume-name> [<load-number>]]","create new volume for S1000 at index"},
+			{CMD_MKVOLI1,"mkdiri1",2,4,NULL,NULL},
+			{CMD_MKVOLI3,"mkvoli3",2,4,"<volume-index> [<volume-name> [<load-number>]]","create new volume for S3000 or CD3000 at index"},
+			{CMD_MKVOLI3,"mkdiri3",2,4,NULL,NULL},
+			{CMD_MKVOLI3CD,"mkvoli3cd",2,4,"<volume-index> [<volume-name> [<load-number>]]","create new volume for CD3000 CD-ROM at index"},
+			{CMD_MKVOLI3CD,"mkdiri3cd",2,4,NULL,NULL},
+			{CMD_LOCK,"lock",1,1,"","acquire lock"},
+			{CMD_UNLOCK,"unlock",1,1,"","release lock"},
+			{CMD_DIRCACHE,"dircache",1,1,"","print cache information"},
+			{CMD_DIRCACHE,"lscache",1,1,NULL,NULL},
+			{CMD_DISABLECACHE,"disablecache",1,1,"","disable cache"},
+			{CMD_ENABLECACHE,"enablecache",1,1,"","enable cache"},
+			{CMD_PLAYWAV,"playwav",1,2,"[<wav-name>]","start playback of current external WAV file"},
+			{CMD_PLAYWAV,"p",1,2,NULL,NULL},
+			{CMD_STOPWAV,"stopwav",1,1,"","stop playback of current external WAV file"},
+			{CMD_STOPWAV,"s",1,1,NULL,NULL},
+			{CMD_DELWAV,"delwav",1,1,"","delete current external WAV file"},
+			{CMD_DELWAV,"rmwav",1,1,NULL,NULL},
+			{CMD_NULL,NULL,0,0,NULL,NULL}
+		};
+
+		if (restartflag){
+			if (readonly){
+				PRINTF_OUT("\n--- read-only mode ---\n");
+			}else{
+				PRINTF_OUT("\n--- read/write mode ---\n");
+			}
+			PRINTF_OUT("\ntry \"help\" for infos\n\n");
+		}
+		
+		for (;;){
+			/* get command */
+			curdir_info(0,NULL);
+			PRINTF_OUT(" > ");
+			FLUSH_ALL;
+			if ((FGETS(cmd,CMDLEN,stdin)==NULL)
+				||(strlen(cmd)==0)){
+				goto main_parser_next;
+			}
+			cmd[strlen(cmd)-1]='\0';
+			if (strlen(cmd)==0){
+				goto main_parser_next;
+			}
+			/* parse command line */
+			for (i=0;i<CMDTOKMAX;i++){
+				if (i==0){
+					p=(char *)strtok(cmd," \t");
+					if (p==NULL){
+						/* no tokens at all */
+						goto main_parser_next;
+					}
+					cmdtok[i]=p;
+				}else{
+					p=(char *)strtok(NULL," \t");
+					if (p==NULL){
+						/* done */
+						break; /* parse command line loop */
+					}
+					cmdtok[i]=p;
+				}
+			}
+			cmdtoknr=i; /* number of tokens */
+#ifdef DEBUGPARSER
+			PRINTF_OUT("parser: cmdtoknr: %i\n",cmdtoknr);
+			for (i=0;i<cmdtoknr;i++){
+				PRINTF_OUT("%i: \"%s\"\n",i,cmdtok[i]);
+			}
+			PRINTF_OUT("\n");
+#endif
+			
+			/* find command */
+			cmdnr=CMD_NULL; /* nothing found yet */
+			for (i=0;cmdtab[i].cmdnr!=CMD_NULL;i++){
+				if (cmdtab[i].cmdstr!=NULL){
+					if (strcmp(cmdtab[i].cmdstr,cmdtok[0])==0){
+						/* found command string */
+						cmdnr=cmdtab[i].cmdnr;
+						break; /* done */
+					}
+				}
+			}
+
+			/* check number of arguments */
+			if ((cmdnr!=CMD_NULL)&&((cmdtoknr<cmdtab[i].cmdtokmin)||(cmdtoknr>cmdtab[i].cmdtokmax))){
+				for (i=0;cmdtab[i].cmdnr!=CMD_NULL;i++){
+					if ((cmdtab[i].cmdnr==cmdnr)&&(cmdtab[i].cmdstr!=NULL)&&(cmdtab[i].cmduse!=NULL)){
+						PRINTF_OUT("usage: %s %s\n\n",cmdtab[i].cmdstr,cmdtab[i].cmduse);
+						break;
+					}
+				}
+				goto main_parser_next;
+			}
+
+			/* execute command */
+			switch (cmdnr){
+			case CMD_EXIT:
+				goto main_exit;
+			case CMD_RESTART:
+			case CMD_RESTARTKEEP:
+				FLUSH_ALL;
+				if (cmdnr==CMD_RESTARTKEEP){
+					curdir_info(0,dirnamebuf); /* save path of current directory */
+					PRINTF_OUT("\n");
+					restartflag=0;
+				}else{
+					PRINTF_OUT("\nrestarting program\n\n");
+					restartflag=1;
+				}
+				goto main_restart;
+			case CMD_HELP:
+				if (cmdtoknr==1){
+					int i,j,k;
+
+					PRINTF_OUT("\ncommands:\n");
+					k=0;
+					for (i=0,j=0;cmdtab[i].cmdnr!=CMD_NULL;i++){
+						if (cmdtab[i].cmdstr!=NULL){
+							if (j%5==0){
+								putchar('\n');
+								k=0;
+							}
+							for (;k<((j%5)*15+2);k++){
+								putchar(' ');
+							}
+							PRINTF_OUT("%s ",cmdtab[i].cmdstr);
+							k+=(int)strlen(cmdtab[i].cmdstr)+1;
+							j++;
+						}
+					}
+					PRINTF_OUT("\n\ntry \"help <cmd>\" for more information about <cmd>\n\n");
+				}else if (cmdtoknr==2){
+					int i,flag;
+
+					/* find command */
+					cmdnr=CMD_NULL; /* nothing found yet */
+					for (i=0;cmdtab[i].cmdnr!=CMD_NULL;i++){
+						if (cmdtab[i].cmdstr!=NULL){
+							if (strcmp(cmdtab[i].cmdstr,cmdtok[1])==0){
+								/* found command string */
+								cmdnr=cmdtab[i].cmdnr;
+								break; /* done */
+							}
+						}
+					}
+					if (cmdnr==CMD_NULL){
+						PRINTF_OUT("unknown command, try \"help\"\n\n");
+						goto main_parser_next;
+					}
+					PRINTF_OUT("\nusage: ");
+					flag=0;
+					for (i=0;cmdtab[i].cmdnr!=CMD_NULL;i++){
+						if (cmdtab[i].cmdnr==cmdnr){
+							if (flag==0){
+								/* first */
+								if (cmdtab[i].cmdstr!=NULL){
+									if (cmdtab[i].cmduse!=NULL){
+										PRINTF_OUT("%s %s\n",cmdtab[i].cmdstr,cmdtab[i].cmduse);
+									}else{
+										PRINTF_OUT("%s\n",cmdtab[i].cmdstr);
+									}
+								}
+								if (cmdtab[i].cmdhelp!=NULL){
+									PRINTF_OUT("\n%s\n",cmdtab[i].cmdhelp);
+								}
+								flag=1;
+							}else{
+								/* found alias */
+								if (flag==1){
+									PRINTF_OUT("\naliases:\n");
+									flag=2;
+								}
+								if (cmdtab[i].cmdstr!=NULL){
+									PRINTF_OUT("  %s\n",cmdtab[i].cmdstr);
+								}
+							}
+						}
+					}
+					PRINTF_OUT("\n");
+				}
+				break;
+			case CMD_DF:
+				{
+					u_int di;
+
+					PRINTF_OUT("\n");
+					akai_list_alldisks(0,NULL);
+					for (di=0;di<disk_num;di++){
+						akai_list_disk(&disk[di],0,NULL);
+					}
+				}
+				break;
+			case CMD_DINFO:
+				PRINTF_OUT("\n");
+				curdir_info(1,NULL); /* 1: verbose */
+				break;
+			case CMD_CD:
+				if (cmdtoknr>=2){
+					if (change_curdir(cmdtok[1],0,NULL,1)<0){ /* NULL,1: check last */
+						PRINTF_ERR("directory not found\n");
+					}
+				}else{
+					change_curdir_home(); /* XXX ignore error */
+				}
+				break;
+			case CMD_CDI:
+				{
+					u_int vi;
+
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("must be on sampler partition level\n");
+						goto main_parser_next;
+					}
+					/* index */
+					vi=(u_int)atoi(cmdtok[1]);
+					if ((vi<1)||(vi>curpartp->volnummax)){
+						PRINTF_ERR("invalid volume index\n");
+						goto main_parser_next;
+					}
+					if (change_curdir(NULL,vi-1,NULL,1)<0){ /* NULL,1: check last */
+						PRINTF_ERR("directory not found\n");
+					}
+				}
+				break;
+			case CMD_DIR:
+				save_curdir(0); /* 0: no modifications */
+				if (cmdtoknr>=2){
+					if (change_curdir(cmdtok[1],0,NULL,1)<0){ /* NULL,1: check last */
+						PRINTF_ERR("directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+				}
+				PRINTF_OUT("\n");
+				list_curdir(0); /* 0: non-recursive */
+				restore_curdir();
+				break;
+			case CMD_DIRREC:
+				PRINTF_OUT("\n");
+				list_curdir(1); /* 1: recursive */
+				break;
+			case CMD_LSTAGS:
+				if (curpartp!=NULL){
+					PRINTF_OUT("\n");
+					akai_list_tags(curpartp);
+				}
+				PRINTF_OUT("\n");
+				list_curfiltertags();
+				PRINTF_OUT("\n");
+				break;
+			case CMD_INITTAGS:
+				{
+					u_int i;
+
+					if ((curdiskp!=NULL)&&(curpartp==NULL)){ /* on disk level? */
+						if (curdiskp->readonly){
+							PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+							goto main_parser_next;
+						}
+						/* all S1000/S3000 harddisk sampler partitions on current disk */
+						for (i=0;i<part_num;i++){
+							/* check if same disk and correct partition type */
+							if ((part[i].diskp!=curdiskp)||(part[i].type!=PART_TYPE_HD)){
+								continue; /* next */
+							}
+							/* now, S1000/S3000 harddisk sampler partition */
+							PRINTF_OUT("partition %c:\n",part[i].letter);
+							akai_rename_tag(&part[i],NULL,0,1); /* 1: wipe, XXX ignore error */
+						}
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on disk level or sampler partition level\n");
+							goto main_parser_next;
+						}
+						if (curdiskp->readonly){
+							PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+							goto main_parser_next;
+						}
+						akai_rename_tag(curpartp,NULL,0,1); /* 1: wipe */
+					}
+					break;
+				}
+			case CMD_RENTAG:
+				{
+					u_int ti;
+
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("must be on sampler partition level\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* index */
+					ti=(u_int)atoi(cmdtok[1]);
+					if ((ti<1)||(ti>AKAI_PARTHEAD_TAGNUM)){
+						PRINTF_ERR("invalid volume index\n");
+						goto main_parser_next;
+					}
+					akai_rename_tag(curpartp,cmdtok[2],ti-1,0); /* 0: don't wipe */
+				}
+				break;
+			case CMD_CDINFO:
+			case CMD_VCDINFO:
+				if (check_curnosamplerpart()){ /* not on sampler partition level? */
+					PRINTF_ERR("must be on sampler partition level\n");
+					goto main_parser_next;
+				}
+				PRINTF_OUT("\n");
+				akai_print_cdinfo(curpartp,(cmdnr==CMD_VCDINFO)?1:0);
+				PRINTF_OUT("\n");
+				break;
+			case CMD_SETCDINFO:
+				{
+					u_int i;
+
+					if ((curdiskp!=NULL)&&(curpartp==NULL)){ /* on disk level? */
+						if (curdiskp->readonly){
+							PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+							goto main_parser_next;
+						}
+						/* all harddisk sampler partitions on current disk */
+						for (i=0;i<part_num;i++){
+							/* check if same disk and correct partition type */
+							if ((part[i].diskp!=curdiskp)||(part[i].type!=PART_TYPE_HD)){
+								continue; /* next */
+							}
+							/* now, S1000/S3000 harddisk sampler partition */
+							PRINTF_OUT("partition %c:\n",part[i].letter);
+							akai_set_cdinfo(&part[i],(cmdtoknr>=2)?cmdtok[1]:NULL); /* XXX ignore error */
+						}
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on disk level or on sampler partition level\n");
+							goto main_parser_next;
+						}
+						if (curdiskp->readonly){
+							PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+							goto main_parser_next;
+						}
+						akai_set_cdinfo(curpartp,(cmdtoknr>=2)?cmdtok[1]:NULL);
+					}
+					break;
+				}
+			case CMD_LCD:
+				if (LCHDIR(cmdtok[1])<0){
+					PRINTF_ERR("invalid directory path\n");
+				}
+				break;
+			case CMD_LDIR:
+				LDIR; /* XXX no error check */
+				break;
+			case CMD_LSFAT:
+				if ((curdiskp==NULL)||(curpartp==NULL)){
+					PRINTF_ERR("must be inside a partition\n");
+					goto main_parser_next;
+				}
+				PRINTF_OUT("\n");
+				print_fat(curpartp);
+				PRINTF_OUT("\n");
+				break;
+			case CMD_LSFATI:
+				{
+					struct file_s tmpfile;
+					u_int fi;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					/* index */
+					fi=(u_int)atoi(cmdtok[1]);
+					if ((fi<1)||(fi>curvolp->fimax)){
+						PRINTF_ERR("invalid file index\n");
+						goto main_parser_next;
+					}
+					/* find file in current volume */
+					if (akai_get_file(curvolp,&tmpfile,fi-1)<0){
+						PRINTF_ERR("file not found\n");
+						goto main_parser_next;
+					}
+					PRINTF_OUT("\n");
+					print_fatchain(curpartp,tmpfile.bstart);
+					PRINTF_OUT("\n");
+				}
+				break;
+			case CMD_LSTFATI:
+				{
+					u_int ti;
+					u_int cstarts,cstarte;
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					/* index */
+					ti=(u_int)atoi(cmdtok[1]);
+					if ((ti<1)||(ti>AKAI_DDTAKE_MAXNUM)){
+						PRINTF_ERR("invalid take index\n");
+						goto main_parser_next;
+					}
+					/* take */
+					if (curpartp->head.dd.take[ti-1].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+						PRINTF_ERR("take not found\n");
+						goto main_parser_next;
+					}
+					PRINTF_OUT("\n");
+					cstarts=(curpartp->head.dd.take[ti-1].cstarts[1]<<8)
+						    +curpartp->head.dd.take[ti-1].cstarts[0];
+					if (cstarts!=0){ /* sample not empty? */
+						PRINTF_OUT("sample:\n");
+						print_ddfatchain(curpartp,cstarts);
+						PRINTF_OUT("\n");
+					}
+					cstarte=(curpartp->head.dd.take[ti-1].cstarte[1]<<8)
+						    +curpartp->head.dd.take[ti-1].cstarte[0];
+					if (cstarte!=0){ /* envelope not empty? */
+						PRINTF_OUT("envelope:\n");
+						print_ddfatchain(curpartp,cstarte);
+						PRINTF_OUT("\n");
+					}
+				}
+				break;
+			case CMD_INFOI:
+				{
+					struct file_s tmpfile;
+					u_int fi;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					/* index */
+					fi=(u_int)atoi(cmdtok[1]);
+					if ((fi<1)||(fi>curvolp->fimax)){
+						PRINTF_ERR("invalid file index\n");
+						goto main_parser_next;
+					}
+					/* find file in current volume */
+					if (akai_get_file(curvolp,&tmpfile,fi-1)<0){
+						PRINTF_ERR("file not found\n");
+						goto main_parser_next;
+					}
+					/* print info */
+					PRINTF_OUT("\n");
+					curdir_info(0,NULL);
+					PRINTF_OUT("/");
+					if (akai_file_info(&tmpfile,1)<1){ /* 1: verbose */
+						PRINTF_OUT("\n");
+					}
+				}
+				break;
+			case CMD_INFOALL:
+				{
+					struct file_s tmpfile;
+					u_int sfi;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					/* all files in current volume */
+					for (sfi=0;sfi<curvolp->fimax;sfi++){
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,sfi)<0){
+							continue; /* next */
+						}
+						/* print info */
+						PRINTF_OUT("\n");
+						curdir_info(0,NULL);
+						PRINTF_OUT("/");
+						akai_file_info(&tmpfile,1); /* 1: verbose */
+					}
+				}
+				break;
+			case CMD_TINFOI:
+				{
+					u_int ti;
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					/* index */
+					ti=(u_int)atoi(cmdtok[1]);
+					if ((ti<1)||(ti>AKAI_DDTAKE_MAXNUM)){
+						PRINTF_ERR("invalid take index\n");
+						goto main_parser_next;
+					}
+					/* take */
+					if (curpartp->head.dd.take[ti-1].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+						PRINTF_ERR("take not found\n");
+						goto main_parser_next;
+					}
+					/* print info */
+					PRINTF_OUT("\n");
+					curdir_info(0,NULL);
+					PRINTF_OUT("/");
+					if (akai_ddtake_info(curpartp,ti-1,1)<1){ /* 1: verbose */
+						PRINTF_OUT("\n");
+					}
+				}
+				break;
+			case CMD_TINFOALL:
+				{
+					u_int ti;
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					/* all DD takes in current DD partition */
+					for (ti=0;ti<AKAI_DDTAKE_MAXNUM;ti++){
+						/* take */
+						if (curpartp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+							continue; /* next */
+						}
+						/* print info */
+						PRINTF_OUT("\n");
+						curdir_info(0,NULL);
+						PRINTF_OUT("/");
+						akai_ddtake_info(curpartp,ti,1); /* 1: verbose */
+					}
+				}
+				break;
+			case CMD_DEL:
+				{
+					struct file_s tmpfile;
+
+					save_curdir(1); /* 1: could be modifications */
+					if (change_curdir(cmdtok[1],0,dirnamebuf,0)<0){
+						PRINTF_ERR("directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be a file in a sampler volume\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (strlen(dirnamebuf)==0){
+						PRINTF_ERR("invalid file name\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* find file in current directory */
+					if (akai_find_file(curvolp,&tmpfile,dirnamebuf)<0){
+						PRINTF_ERR("file not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* delete file */
+					if (akai_delete_file(&tmpfile)<0){
+						PRINTF_ERR("delete error\n");
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_DELI:
+				{
+					struct file_s tmpfile;
+					u_int fi;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* index */
+					fi=(u_int)atoi(cmdtok[1]);
+					if ((fi<1)||(fi>curvolp->fimax)){
+						PRINTF_ERR("invalid file index\n");
+						goto main_parser_next;
+					}
+					/* find file in current volume */
+					if (akai_get_file(curvolp,&tmpfile,fi-1)<0){
+						PRINTF_ERR("file not found\n");
+						goto main_parser_next;
+					}
+					/* delete file */
+					if (akai_delete_file(&tmpfile)<0){
+						PRINTF_ERR("delete error\n");
+					}
+				}
+				break;
+			case CMD_TDELI:
+				{
+					u_int ti;
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* index */
+					ti=(u_int)atoi(cmdtok[1]);
+					if ((ti<1)||(ti>AKAI_DDTAKE_MAXNUM)){
+						PRINTF_ERR("invalid take index\n");
+						goto main_parser_next;
+					}
+					/* delete take */
+					if (akai_delete_ddtake(curpartp,ti-1)<0){
+						PRINTF_ERR("cannot delete take\n");
+					}
+				}
+				break;
+			case CMD_REN:
+			case CMD_RENI:
+				{
+					struct file_s tmpfile,dummyfile;
+					struct vol_s tmpvol;
+					u_int sfi,dfi;
+
+					/* source */
+					if (cmdnr==CMD_RENI){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						/* source file index */
+						sfi=(u_int)atoi(cmdtok[1]);
+						if ((sfi<1)||(sfi>curvolp->fimax)){
+							PRINTF_ERR("invalid source file index\n");
+							goto main_parser_next;
+						}
+						/* find file in current volume */
+						/* must save current volume for tmpfile, since change_curdir below will possibly change volume */
+						akai_copy_structvol(curvolp,&tmpvol);
+						if (akai_get_file(&tmpvol,&tmpfile,sfi-1)<0){
+							PRINTF_ERR("file not found\n");
+							goto main_parser_next;
+						}
+					}else{
+						save_curdir(0); /* 0: no modifications */
+						if (change_curdir(cmdtok[1],0,dirnamebuf,0)<0){
+							PRINTF_ERR("source directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("source must be a file in a sampler volume\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (strlen(dirnamebuf)==0){
+							PRINTF_ERR("invalid file name\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						/* find file in current directory */
+						/* must save current volume for tmpfile */
+						akai_copy_structvol(curvolp,&tmpvol);
+						if (akai_find_file(&tmpvol,&tmpfile,dirnamebuf)<0){
+							PRINTF_ERR("file not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						restore_curdir();
+					}
+					/* destination */
+					save_curdir(1); /* 1: could be modifications */
+					if (change_curdir(cmdtok[2],0,dirnamebuf,0)<0){
+						PRINTF_ERR("destination directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("destination must be inside a volume\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (strlen(dirnamebuf)==0){ /* empty destination name? */
+						/* take source name */
+						strcpy(dirnamebuf,tmpfile.name);
+					}
+					if (cmdtoknr>=4){
+						/* destination file index */
+						dfi=(u_int)atoi(cmdtok[3]);
+						if ((dfi<1)||(dfi>curvolp->fimax)){
+							PRINTF_ERR("invalid destination file index\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						dfi--;
+						/* XXX akai_rename_file() below will check if index is free */
+					}else{
+						dfi=AKAI_CREATE_FILE_NOINDEX;
+#if 1
+						/* check if new file name already used */
+						if (akai_find_file(curvolp,&dummyfile,dirnamebuf)==0){
+							PRINTF_ERR("file name already used\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+#endif
+					}
+					/* rename file */
+					if (akai_rename_file(&tmpfile,dirnamebuf,curvolp,dfi,NULL,tmpfile.osver)<0){
+						PRINTF_ERR("cannot rename file\n");
+					}
+					/* fix name in header (if necessary) */
+					akai_fixramname(&tmpfile); /* ignore error */
+					restore_curdir();
+				}
+				break;
+			case CMD_SETOSVERI:
+			case CMD_SETUNCOMPRI:
+			case CMD_UPDATEUNCOMPRI:
+				{
+					struct file_s tmpfile;
+					u_int fi;
+					u_int osver;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* index */
+					fi=(u_int)atoi(cmdtok[1]);
+					if ((fi<1)||(fi>curvolp->fimax)){
+						PRINTF_ERR("invalid file index\n");
+						goto main_parser_next;
+					}
+					/* find file in current volume */
+					if (akai_get_file(curvolp,&tmpfile,fi-1)<0){
+						PRINTF_ERR("file not found\n");
+						goto main_parser_next;
+					}
+					if (cmdnr==CMD_SETOSVERI){
+						if (curvolp->type==AKAI_VOL_TYPE_S900){
+							PRINTF_ERR("must be an S1000/S3000 volume\n");
+							goto main_parser_next;
+						}
+						/* OS version of file in S1000/S3000 volume */
+						if (strstr(cmdtok[2],".")!=NULL){
+							/* format: "XX.XX" */
+							osver=(u_int)(100.0*atof(cmdtok[2]));
+							osver=(((osver/100))<<8)|(osver%100);
+						}else{
+							/* integer format */
+							osver=(u_int)atoi(cmdtok[2]);
+						}
+					}else{
+						if (curvolp->type!=AKAI_VOL_TYPE_S900){
+							PRINTF_ERR("must be an S900 volume\n");
+							goto main_parser_next;
+						}
+						if (tmpfile.osver==0){
+							PRINTF_ERR("not a compressed file\n");
+							goto main_parser_next;
+						}
+						if (cmdtoknr>=3){
+							/* given uncompr value in integer format */
+							osver=(u_int)atoi(cmdtok[2]);
+						}else{
+							/* update uncompr value */
+							if (akai_s900comprfile_updateuncompr(&tmpfile)<0){
+								PRINTF_ERR("cannot set uncompr value\n");
+							}
+							goto main_parser_next; /* done */
+						}
+					}
+					/* set osver of file */
+					/* Note: akai_create_file() will correct osver if necessary */
+					if (akai_rename_file(&tmpfile,NULL,curvolp,AKAI_CREATE_FILE_NOINDEX,NULL,osver)<0){
+						if (cmdnr==CMD_SETOSVERI){
+							PRINTF_ERR("cannot set OS version\n");
+						}else{
+							PRINTF_ERR("cannot set uncompr value\n");
+						}
+					}
+				}
+				break;
+			case CMD_SETOSVERALL:
+				{
+					struct file_s tmpfile;
+					u_int fi;
+					u_int osver;
+					u_int fcount;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					if (curvolp->type==AKAI_VOL_TYPE_S900){
+						PRINTF_ERR("must be an S1000/S3000 volume\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* OS version of file in S1000/S3000 volume */
+					if (strstr(cmdtok[2],".")!=NULL){
+						/* format: "XX.XX" */
+						osver=(u_int)(100.0*atof(cmdtok[2]));
+						osver=(((osver/100))<<8)|(osver%100);
+					}else{
+						/* integer format */
+						osver=(u_int)atoi(cmdtok[2]);
+					}
+					/* all files in current volume */
+					fcount=0;
+					for (fi=0;fi<curvolp->fimax;fi++){
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,fi)<0){
+							continue; /* next */
+						}
+						PRINTF_OUT("updating \"%s\"\n",tmpfile.name);
+						FLUSH_ALL;
+						/* set osver of file */
+						/* Note: akai_create_file() will correct osver if necessary */
+						if (akai_rename_file(&tmpfile,NULL,curvolp,AKAI_CREATE_FILE_NOINDEX,NULL,osver)<0){
+							PRINTF_ERR("cannot set OS version\n");
+							continue; /* next */
+						}
+						fcount++;
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("updated %u file(s)\n",fcount);
+				}
+				break;
+			case CMD_UPDATEUNCOMPRALL:
+				{
+					struct file_s tmpfile;
+					u_int fi;
+					u_int fcount;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					if (curvolp->type!=AKAI_VOL_TYPE_S900){
+						PRINTF_ERR("must be an S900 volume\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* all files in current volume */
+					fcount=0;
+					for (fi=0;fi<curvolp->fimax;fi++){
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,fi)<0){
+							continue; /* next */
+						}
+						if (tmpfile.osver!=0){ /* compressed file? */
+							PRINTF_OUT("updating \"%s\"\n",tmpfile.name);
+							FLUSH_ALL;
+							/* update uncompr value */
+							if (akai_s900comprfile_updateuncompr(&tmpfile)<0){
+								PRINTF_ERR("cannot set uncompr value\n");
+								continue; /* next */
+							}
+							fcount++;
+						}
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("updated %u file(s)\n",fcount);
+				}
+				break;
+			case CMD_SAMPLE900UNCOMPR:
+			case CMD_SAMPLE900UNCOMPRI:
+			case CMD_SAMPLE900COMPR:
+			case CMD_SAMPLE900COMPRI:
+				{
+					struct file_s tmpfile;
+					struct vol_s tmpvol;
+					struct vol_s destvol;
+					struct vol_s *volp;
+					int destreadonly;
+					u_int destindex;
+					u_int fi;
+
+					destreadonly=1; /* XXX */
+					destindex=0; /* XXX */
+					if ((cmdnr==CMD_SAMPLE900UNCOMPRI)||(cmdnr==CMD_SAMPLE900COMPRI)){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						destreadonly=curdiskp->readonly;
+						destindex=curdiskp->index;
+						/* index */
+						fi=(u_int)atoi(cmdtok[1]);
+						if ((fi<1)||(fi>curvolp->fimax)){
+							PRINTF_ERR("invalid file index\n");
+							goto main_parser_next;
+						}
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,fi-1)<0){
+							PRINTF_ERR("file not found\n");
+							goto main_parser_next;
+						}
+					}else{
+						save_curdir(0); /* 0: no modifications */
+						if (change_curdir(cmdtok[1],0,dirnamebuf,0)<0){
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be a file in a sampler volume\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						destreadonly=curdiskp->readonly;
+						destindex=curdiskp->index;
+						if (strlen(dirnamebuf)==0){
+							PRINTF_ERR("invalid file name\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						/* find file in current directory */
+						/* must save current volume for tmpfile */
+						akai_copy_structvol(curvolp,&tmpvol);
+						if (akai_find_file(&tmpvol,&tmpfile,dirnamebuf)<0){
+							PRINTF_ERR("file not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						restore_curdir();
+					}
+					if (cmdtoknr>=3){
+						save_curdir(0); /* 0: no modifications */
+						/* given destination volume */
+						if (change_curdir(cmdtok[2],0,NULL,1)<0){ /* NULL,1: check last */
+							PRINTF_ERR("destination volume not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("destination must be a volume\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						destreadonly=curdiskp->readonly;
+						destindex=curdiskp->index;
+						/* must save current volume */
+						akai_copy_structvol(curvolp,&destvol);
+						volp=&destvol;
+						restore_curdir();
+					}else{
+						/* replace file in same volume */
+						volp=NULL;
+					}
+					if (destreadonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",destindex);
+						goto main_parser_next;
+					}
+					save_curdir(1); /* 1: could be modifications */
+					if ((cmdnr==CMD_SAMPLE900UNCOMPR)||(cmdnr==CMD_SAMPLE900UNCOMPRI)){
+						PRINTF_OUT("uncompressing \"%s\"\n",tmpfile.name);
+						FLUSH_ALL;
+						/* uncompress S900 compressed sample file */
+						akai_sample900_compr2noncompr(&tmpfile,volp); /* ignore error */
+					}else{
+						PRINTF_OUT("compressing \"%s\"\n",tmpfile.name);
+						FLUSH_ALL;
+						/* compress S900 non-compressed sample file */
+						akai_sample900_noncompr2compr(&tmpfile,volp); /* ignore error */
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_SAMPLE900UNCOMPRALL:
+			case CMD_SAMPLE900COMPRALL:
+				{
+					struct file_s tmpfile;
+					struct vol_s destvol;
+					struct vol_s *volp;
+					int destreadonly;
+					u_int destindex;
+					u_int fi;
+					u_int fcount;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					destreadonly=curdiskp->readonly;
+					destindex=curdiskp->index;
+					if (cmdtoknr>=2){
+						save_curdir(0); /* 0: no modifications */
+						/* given destination volume */
+						if (change_curdir(cmdtok[1],0,NULL,1)<0){ /* NULL,1: check last */
+							PRINTF_ERR("destination volume not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("destination must be a volume\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						destreadonly=curdiskp->readonly;
+						destindex=curdiskp->index;
+						/* must save current volume */
+						akai_copy_structvol(curvolp,&destvol);
+						volp=&destvol;
+						restore_curdir();
+					}else{
+						/* replace files in same volume */
+						volp=NULL;
+					}
+					if (destreadonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",destindex);
+						goto main_parser_next;
+					}
+					/* all files in current volume */
+					save_curdir(1); /* 1: could be modifications */
+					fcount=0;
+					for (fi=0;fi<curvolp->fimax;fi++){
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,fi)<0){
+							continue; /* next */
+						}
+						if (cmdnr==CMD_SAMPLE900UNCOMPRALL){
+							if ((tmpfile.type!=AKAI_SAMPLE900_FTYPE)||(tmpfile.osver==0)){ /* not S900 compressed sample file? */
+								continue; /* next */
+							}
+							PRINTF_OUT("uncompressing \"%s\"\n",tmpfile.name);
+							FLUSH_ALL;
+							/* uncompress S900 compressed sample file */
+							if (akai_sample900_compr2noncompr(&tmpfile,volp)<0){
+								continue; /* next */
+							}
+							fcount++;
+						}else{
+							if ((tmpfile.type!=AKAI_SAMPLE900_FTYPE)||(tmpfile.osver!=0)){ /* not S900 non-compressed sample file? */
+								continue; /* next */
+							}
+							PRINTF_OUT("compressing \"%s\"\n",tmpfile.name);
+							FLUSH_ALL;
+							/* compress S900 non-compressed sample file */
+							if (akai_sample900_noncompr2compr(&tmpfile,volp)<0){
+								continue; /* next */
+							}
+							fcount++;
+						}
+					}
+					restore_curdir();
+					FLUSH_ALL;
+					if (cmdnr==CMD_SAMPLE900UNCOMPRALL){
+						PRINTF_OUT("uncompressed %u file(s)\n",fcount);
+					}else{
+						PRINTF_OUT("compressed %u file(s)\n",fcount);
+					}
+				}
+				break;
+			case CMD_FIXRAMNAME:
+			case CMD_FIXRAMNAMEI:
+				{
+					struct file_s tmpfile;
+					struct vol_s tmpvol;
+					u_int fi;
+
+					if (cmdnr==CMD_FIXRAMNAMEI){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						if (curdiskp->readonly){
+							PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+							goto main_parser_next;
+						}
+						/* index */
+						fi=(u_int)atoi(cmdtok[1]);
+						if ((fi<1)||(fi>curvolp->fimax)){
+							PRINTF_ERR("invalid file index\n");
+							goto main_parser_next;
+						}
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,fi-1)<0){
+							PRINTF_ERR("file not found\n");
+							goto main_parser_next;
+						}
+					}else{
+						save_curdir(0); /* 0: no modifications */
+						if (change_curdir(cmdtok[1],0,dirnamebuf,0)<0){
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be a file in a sampler volume\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (curdiskp->readonly){
+							PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (strlen(dirnamebuf)==0){
+							PRINTF_ERR("invalid file name\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						/* find file in current directory */
+						/* must save current volume for tmpfile */
+						akai_copy_structvol(curvolp,&tmpvol);
+						if (akai_find_file(&tmpvol,&tmpfile,dirnamebuf)<0){
+							PRINTF_ERR("file not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						restore_curdir();
+					}
+					/* fix name in header (if necessary) */
+					akai_fixramname(&tmpfile); /* ignore error */
+				}
+				break;
+			case CMD_FIXRAMNAMEALL:
+				{
+					struct file_s tmpfile;
+					u_int fi;
+					u_int fcount;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* all files in current volume */
+					fcount=0;
+					for (fi=0;fi<curvolp->fimax;fi++){
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,fi)<0){
+							continue; /* next */
+						}
+						PRINTF_OUT("fixing \"%s\"\n",tmpfile.name);
+						FLUSH_ALL;
+						/* fix name in header (if necessary) */
+						if (akai_fixramname(&tmpfile)<0){
+							continue; /* next */
+						}
+						fcount++;
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("fixed %u file(s)\n",fcount);
+				}
+				break;
+			case CMD_CLRTAGI:
+			case CMD_SETTAGI:
+				{
+					struct file_s tmpfile;
+					u_int fi,ti;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					if (curvolp->type==AKAI_VOL_TYPE_S900){
+						PRINTF_ERR("no tags for this volume type\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* file index */
+					fi=(u_int)atoi(cmdtok[1]);
+					if ((fi<1)||(fi>curvolp->fimax)){
+						PRINTF_ERR("invalid file index\n");
+						goto main_parser_next;
+					}
+					/* find file in current volume */
+					if (akai_get_file(curvolp,&tmpfile,fi-1)<0){
+						PRINTF_ERR("file not found\n");
+						goto main_parser_next;
+					}
+					/* tag index */
+					if ((cmdnr==CMD_CLRTAGI)&&(strcasecmp(cmdtok[2],"all")==0)){
+						/* clear all */
+						if (tmpfile.osver<=AKAI_OSVER_S1100MAX){ /* XXX */
+							ti=AKAI_FILE_TAGS1000;
+						}else{
+							ti=AKAI_FILE_TAGFREE;
+						}
+					}else{
+						ti=(u_int)atoi(cmdtok[2]);
+						if ((ti<1)||(ti>AKAI_PARTHEAD_TAGNUM)){
+							PRINTF_ERR("invalid tag index\n");
+							goto main_parser_next;
+						}
+					}
+					/* set/clear tag */
+					if (cmdnr==CMD_SETTAGI){
+						if (akai_set_filetag(tmpfile.tag,ti)<0){
+							goto main_parser_next;
+						}
+					}else{
+						if (akai_clear_filetag(tmpfile.tag,ti)<0){
+							goto main_parser_next;
+						}
+					}
+					/* update file */
+					if (akai_rename_file(&tmpfile,NULL,NULL,AKAI_CREATE_FILE_NOINDEX,tmpfile.tag,tmpfile.osver)<0){
+						PRINTF_ERR("cannot update file\n");
+					}
+				}
+				break;
+			case CMD_CLRTAGALL:
+			case CMD_SETTAGALL:
+				{
+					struct file_s tmpfile;
+					u_int fi,ti;
+					u_int fcount;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					if (curvolp->type==AKAI_VOL_TYPE_S900){
+						PRINTF_ERR("no tags for this volume type\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* tag index */
+					if ((cmdnr==CMD_CLRTAGALL)&&(strcasecmp(cmdtok[1],"all")==0)){
+						/* clear all */
+						ti=AKAI_FILE_TAGFREE;
+						/* Note: ti will be adjusted below if necessary */
+					}else{
+						ti=(u_int)atoi(cmdtok[1]);
+						if ((ti<1)||(ti>AKAI_PARTHEAD_TAGNUM)){
+							PRINTF_ERR("invalid tag index\n");
+							goto main_parser_next;
+						}
+					}
+					/* all files in current volume */
+					fcount=0;
+					for (fi=0;fi<curvolp->fimax;fi++){
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,fi)<0){
+							continue; /* next */
+						}
+						/* adjust tag index if necessary */
+						if ((cmdnr==CMD_CLRTAGALL)&&((ti==AKAI_FILE_TAGFREE)||(ti==AKAI_FILE_TAGS1000))){
+							/* clear all */
+							if (tmpfile.osver<=AKAI_OSVER_S1100MAX){ /* XXX */
+								ti=AKAI_FILE_TAGS1000;
+							}else{
+								ti=AKAI_FILE_TAGFREE;
+							}
+						}
+						PRINTF_OUT("updating \"%s\"\n",tmpfile.name);
+						FLUSH_ALL;
+						/* set/clear tag */
+						if (cmdnr==CMD_SETTAGALL){
+							if (akai_set_filetag(tmpfile.tag,ti)<0){
+								PRINTF_ERR("cannot set tag\n");
+								continue; /* next */
+							}
+						}else{
+							if (akai_clear_filetag(tmpfile.tag,ti)<0){
+								PRINTF_ERR("cannot clear tag\n");
+								continue; /* next */
+							}
+						}
+						/* update file */
+						if (akai_rename_file(&tmpfile,NULL,NULL,AKAI_CREATE_FILE_NOINDEX,tmpfile.tag,tmpfile.osver)<0){
+							PRINTF_ERR("cannot update file\n");
+							continue; /* next */
+						}
+						fcount++;
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("updated %u file(s)\n",fcount);
+				}
+				break;
+			case CMD_TRENI:
+				{
+					u_int ti;
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* index */
+					ti=(u_int)atoi(cmdtok[1]);
+					if ((ti<1)||(ti>AKAI_DDTAKE_MAXNUM)){
+						PRINTF_ERR("invalid take index\n");
+						goto main_parser_next;
+					}
+					/* rename take */
+					if (akai_rename_ddtake(curpartp,ti-1,cmdtok[2])<0){
+						PRINTF_ERR("cannot rename take\n");
+					}
+				}
+				break;
+			case CMD_CLRFILTERTAG:
+			case CMD_SETFILTERTAG:
+				{
+					u_int ti;
+
+					/* tag index */
+					if ((cmdnr==CMD_CLRFILTERTAG)&&(strcasecmp(cmdtok[1],"all")==0)){
+						ti=AKAI_FILE_TAGFREE; /* clear all */
+					}else{
+						ti=(u_int)atoi(cmdtok[1]);
+						if ((ti<1)||(ti>AKAI_PARTHEAD_TAGNUM)){
+							PRINTF_ERR("invalid tag index\n");
+							goto main_parser_next;
+						}
+					}
+					/* set/clear tag */
+					if (cmdnr==CMD_SETFILTERTAG){
+						if (akai_set_filetag(curfiltertag,ti)<0){
+							goto main_parser_next;
+						}
+					}else{
+						if (akai_clear_filetag(curfiltertag,ti)<0){
+							goto main_parser_next;
+						}
+					}
+				}
+				break;
+			case CMD_COPY:
+			case CMD_COPYI:
+				{
+					struct file_s tmpfile,dstfile;
+					struct vol_s tmpvol;
+					u_int sfi,dfi;
+
+					/* source */
+					if (cmdnr==CMD_COPYI){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						/* source file index */
+						sfi=(u_int)atoi(cmdtok[1]);
+						if ((sfi<1)||(sfi>curvolp->fimax)){
+							PRINTF_ERR("invalid source file index\n");
+							goto main_parser_next;
+						}
+						/* find file in current volume */
+						/* must save current volume for tmpfile, since change_curdir below will possibly change volume */
+						akai_copy_structvol(curvolp,&tmpvol);
+						if (akai_get_file(&tmpvol,&tmpfile,sfi-1)<0){
+							PRINTF_ERR("file not found\n");
+							goto main_parser_next;
+						}
+					}else{
+						save_curdir(0); /* 0: no modifications */
+						if (change_curdir(cmdtok[1],0,dirnamebuf,0)<0){
+							PRINTF_ERR("source directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("source must be a file in a sampler volume\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (strlen(dirnamebuf)==0){
+							PRINTF_ERR("invalid file name\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						/* find file in current directory */
+						/* must save current volume for tmpfile */
+						akai_copy_structvol(curvolp,&tmpvol);
+						if (akai_find_file(&tmpvol,&tmpfile,dirnamebuf)<0){
+							PRINTF_ERR("source file not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						restore_curdir();
+					}
+					/* destination */
+					save_curdir(1); /* 1: could be modifications */
+					if (change_curdir(cmdtok[2],0,dirnamebuf,0)<0){
+						PRINTF_ERR("destination directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("destination must be inside a volume\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (strlen(dirnamebuf)==0){ /* empty destination name? */
+						/* take source name */
+						strcpy(dirnamebuf,tmpfile.name);
+					}
+					if (cmdtoknr>=4){
+						/* destination file index */
+						dfi=(u_int)atoi(cmdtok[3]);
+						if ((dfi<1)||(dfi>curvolp->fimax)){
+							PRINTF_ERR("invalid destination file index\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						dfi--;
+						/* XXX copy_file() below will check if index is free */
+					}else{
+						dfi=AKAI_CREATE_FILE_NOINDEX;
+					}
+					/* copy file */
+					if (copy_file(&tmpfile,curvolp,&dstfile,dfi,dirnamebuf,1)<0){ /* 1: overwrite */
+						PRINTF_ERR("cannot copy file\n");
+					}
+					/* fix name in header (if necessary) */
+					akai_fixramname(&dstfile); /* ignore error */
+					restore_curdir();
+				}
+				break;
+			case CMD_COPYVOL:
+			case CMD_COPYVOLI:
+				{
+					struct vol_s tmpvol;
+					u_int vi;
+
+					/* source */
+					if (cmdnr==CMD_COPYVOLI){
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on sampler partition level\n");
+							goto main_parser_next;
+						}
+						/* index */
+						vi=(u_int)atoi(cmdtok[1]);
+						if ((vi<1)||(vi>curpartp->volnummax)){
+							PRINTF_ERR("invalid source volume index\n");
+							goto main_parser_next;
+						}
+						/* find volume in current partition */
+						if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+							PRINTF_ERR("source directory not found\n");
+							goto main_parser_next;
+						}
+					}else{
+						save_curdir(0); /* 0: no modifications */
+						if (change_curdir(cmdtok[1],0,NULL,1)<0){ /* NULL,1: check last */
+							PRINTF_ERR("source directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("source must be a volume\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						/* must save current volume, since change_curdir below will possibly change volume */
+						akai_copy_structvol(curvolp,&tmpvol);
+						restore_curdir();
+					}
+					/* destination */
+					save_curdir(1); /* 1: could be modifications */
+					if (change_curdir(cmdtok[2],0,dirnamebuf,0)<0){
+						PRINTF_ERR("destination directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("destination must be a volume\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (strlen(dirnamebuf)==0){ /* empty destination name? */
+						/* take source name */
+						strcpy(dirnamebuf,tmpvol.name);
+					}
+					if ((strcmp(dirnamebuf,".")==0)||(strcmp(dirnamebuf,"..")==0)){
+						PRINTF_ERR("invalid destination volume name\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* copy */
+					if (copy_vol_allfiles(&tmpvol,curpartp,dirnamebuf,1,1)<0){ /* 1: overwrite, 1: verbose */
+						PRINTF_ERR("copy error\n");
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_COPYPART:
+				{
+					struct part_s *tmppartp;
+
+					/* source */
+					save_curdir(0); /* 0: no modifications */
+					if (change_curdir(cmdtok[1],0,NULL,1)<0){ /* NULL,1: check last */
+						PRINTF_ERR("source directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("source must be a sampler partition\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					tmppartp=curpartp; /* source partition */
+					restore_curdir();
+					/* destination */
+					/* Note: allow invalid destination partition!!! */
+					save_curdir(1); /* 1: could be modifications */
+					if (change_curdir(cmdtok[2],0,NULL,0)<0){ /* NULL,0: don't check last */
+						PRINTF_ERR("destination directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("destination must be a sampler partition\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* copy */
+					if (copy_part_allvols(tmppartp,curpartp,1,2)<0){ /* 1: overwrite, 2: verbose */
+						PRINTF_ERR("copy error\n");
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_COPYTAGS:
+				{
+					struct part_s *tmppartp;
+
+					/* source */
+					save_curdir(0); /* 0: no modifications */
+					if (change_curdir(cmdtok[1],0,NULL,1)<0){ /* NULL,1: check last */
+						PRINTF_ERR("source directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("source must be a sampler partition\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					tmppartp=curpartp; /* source partition */
+					restore_curdir();
+					/* destination */
+					save_curdir(1); /* 1: could be modifications */
+					if (change_curdir(cmdtok[2],0,NULL,1)<0){ /* NULL,1: check last */
+						PRINTF_ERR("destination directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("destination must be a sampler partition\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* copy */
+					if (copy_tags(tmppartp,curpartp)<0){
+						PRINTF_ERR("copy error\n");
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_WIPEVOL:
+			case CMD_DELVOL:
+				{
+
+					/* Note: allow invalid volume to be deleted!!! */
+					/* Note: might delete original current volume!!! */
+					save_curdir(1); /* 1: could be modifications */
+					if (change_curdir(cmdtok[1],0,NULL,0)<0){ /* NULL,0: don't check last */
+						PRINTF_ERR("directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be a volume\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* wipe or delete volume */
+					if (akai_wipe_vol(curvolp,(cmdnr==CMD_DELVOL)?1:0)<0){
+						PRINTF_ERR("delete error\n");
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_WIPEVOLI:
+			case CMD_DELVOLI:
+				{
+					struct vol_s tmpvol;
+					u_int vi;
+
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("must be on sampler partition level\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* index */
+					vi=(u_int)atoi(cmdtok[1]);
+					if ((vi<1)||(vi>curpartp->volnummax)){
+						PRINTF_ERR("invalid volume index\n");
+						goto main_parser_next;
+					}
+					/* find volume in current partition */
+					if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+						PRINTF_ERR("volume not found\n");
+						goto main_parser_next;
+					}
+					/* Note: volume may be corrupt */
+					/* wipe or delete volume */
+					if (akai_wipe_vol(&tmpvol,(cmdnr==CMD_DELVOLI)?1:0)<0){
+						PRINTF_ERR("delete error\n");
+					}
+				}
+				break;
+			case CMD_FORMATFLOPPYL9:
+			case CMD_FORMATFLOPPYL1:
+			case CMD_FORMATFLOPPYL3:
+			case CMD_FORMATFLOPPYH9:
+			case CMD_FORMATFLOPPYH1:
+			case CMD_FORMATFLOPPYH3:
+				{
+					int ret;
+					int lodensflag,s3000flag,s900flag;
+
+					if (curdiskp==NULL){
+						PRINTF_ERR("must be on a disk\n");
+						goto main_parser_next;
+					}
+					if ((curdiskp->type!=DISK_TYPE_FLL)&&(curdiskp->type!=DISK_TYPE_FLH)){ /* not a floppy? */
+						PRINTF_ERR("must be a floppy\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					if (blk_cache_enable){ /* cache enabled? */
+						flush_blk_cache(); /* XXX if error, maybe next time more luck */
+					}
+
+					switch (cmdnr){
+					case CMD_FORMATFLOPPYL9:
+						lodensflag=1;
+						s3000flag=0;
+						s900flag=1;
+						break;
+					case CMD_FORMATFLOPPYL1:
+						lodensflag=1;
+						s3000flag=0;
+						s900flag=0;
+						break;
+					case CMD_FORMATFLOPPYL3:
+						lodensflag=1;
+						s3000flag=1;
+						s900flag=0;
+						break;
+					case CMD_FORMATFLOPPYH9:
+						lodensflag=0;
+						s3000flag=0;
+						s900flag=1;
+						break;
+					case CMD_FORMATFLOPPYH1:
+						lodensflag=0;
+						s3000flag=0;
+						s900flag=0;
+						break;
+					case CMD_FORMATFLOPPYH3:
+					default:
+						lodensflag=0;
+						s3000flag=1;
+						s900flag=0;
+						break;
+					}
+
+#ifdef _VISUALCPP
+					if (curdiskp->fldrn>=0){ /* is floppy drive? */
+						if ((lodensflag&&(curdiskp->type==DISK_TYPE_FLH))
+							||((!lodensflag)&&(curdiskp->type==DISK_TYPE_FLL))){ /* incompatible? */
+							PRINTF_ERR("disk%u: chosen filesystem is incompatible with floppy type\n",curdiskp->index);
+							goto main_parser_next;
+						}
+						/* low-level format */
+						PRINTF_OUT("\nlow-level formatting disk%u as %s floppy\n",
+							curdiskp->index,lodensflag?"low-density":"high-density");
+						FLUSH_ALL;
+						if (fldr_format(curdiskp->fldrn)<0){
+#if 0 /* XXX ignore error, continue */
+							PRINTF_ERR("format error\n");
+							FLUSH_ALL;
+							PRINTF_OUT("\nrestarting program\n\n");
+							restartflag=1;
+							goto main_restart;
+#endif
+						}
+					}else
+#endif /* _VISUALCPP */
+					{
+						u_char fbuf[AKAI_FL_BLOCKSIZE];
+						u_int i;
+
+						/* erase whole disk */
+						PRINTF_OUT("\nerasing disk%u\n",curdiskp->index);
+						FLUSH_ALL;
+						bzero(fbuf,AKAI_FL_BLOCKSIZE);
+						for (i=0;i<curdiskp->bsize;i++){
+							PRINTF_OUT("\rblock 0x%04x",i);
+							FLUSH_ALL;
+							/* Note: checked for floppy drive above -> not a floppy drive here */
+							/*       -> no need to check if floppy inserted here */
+							/* write block */
+							if (io_blks(curdiskp->fd,
+#ifdef _VISUALCPP
+										curdiskp->fldrn,
+#endif /* _VISUALCPP */
+										curdiskp->startoff,
+										fbuf,
+										i,
+										1,
+										curdiskp->blksize,
+										0,IO_BLKS_WRITE)<0){ /* 0: don't alloc cache */
+								PRINTF_OUT(" - cannot write block\n");
+								FLUSH_ALL;
+#if 0 /* XXX ignore error, continue */
+								PRINTF_ERR("format error\n");
+								FLUSH_ALL;
+								PRINTF_OUT("\nrestarting program\n\n");
+								restartflag=1;
+								goto main_restart;
+#endif
+							}
+						}
+						PRINTF_OUT("\rdone        \n");
+					}
+
+					/* create filesystem */
+					PRINTF_OUT("\ncreating filesystem on disk%u\n",curdiskp->index);
+					FLUSH_ALL;
+					ret=akai_wipe_floppy(curdiskp,lodensflag,s3000flag,s900flag);
+					/* Note: blksize might have changed now!!! */
+					if (ret!=0){
+						PRINTF_ERR("format error\n");
+						FLUSH_ALL;
+					}
+					if (ret<0){ /* non-fatal? */
+						goto main_parser_next;
+					}
+					/* must exit (or restart) now!!! */
+					if (ret>0){ /* fatal? */
+						mainret=1; /* error */
+						goto main_exit;
+					}
+					FLUSH_ALL;
+
+#if 1
+					/* scan for bad blocks/clusters */
+					PRINTF_OUT("\nscanning for bad blocks\n");
+					/* Note: akai_wipe_floppy() above has initialized part[0] */
+					if (akai_scanbad(&part[0],1)<0){ /* 1: mark bad blocks */
+						PRINTF_OUT("invalid partition\n");
+					}else{
+						PRINTF_OUT("\rdone                           \n");
+					}
+#endif
+
+					PRINTF_OUT("\nrestarting program\n\n");
+					restartflag=1;
+					goto main_restart;
+				}
+				break;
+			case CMD_WIPEFLOPPY:
+				{
+					int ret;
+
+					if (check_curnosamplervol() /* not inside a sampler volume? */
+						||((curdiskp->type!=DISK_TYPE_FLL)&&(curdiskp->type!=DISK_TYPE_FLH))){ /* or not a floppy? */
+						PRINTF_ERR("must be inside a floppy volume\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					if (blk_cache_enable){ /* cache enabled? */
+						flush_blk_cache(); /* XXX if error, maybe next time more luck */
+					}
+
+					/* create filesystem */
+					PRINTF_OUT("\ncreating filesystem on disk%u\n",curdiskp->index);
+					FLUSH_ALL;
+					ret=akai_wipe_floppy(curdiskp,
+							curpartp->type==PART_TYPE_FLL,
+							(curvolp->type==AKAI_VOL_TYPE_S3000)||(curvolp->type==AKAI_VOL_TYPE_CD3000),
+							(curvolp->type==AKAI_VOL_TYPE_S900));
+					/* Note: blksize might have changed now!!! */
+					if (ret!=0){
+						PRINTF_ERR("format error\n");
+						FLUSH_ALL;
+					}
+					if (ret<0){ /* non-fatal? */
+						goto main_parser_next;
+					}
+					/* must exit (or restart) now!!! */
+					if (ret>0){ /* fatal? */
+						mainret=1; /* error */
+						goto main_exit;
+					}
+					FLUSH_ALL;
+
+					PRINTF_OUT("\nrestarting program\n\n");
+					restartflag=1;
+					goto main_restart;
+				}
+				break;
+			case CMD_FORMATHARDDISK9:
+				{
+					u_int l;
+					u_int totb;
+					int ret;
+
+					if (curdiskp==NULL){
+						PRINTF_ERR("must be on a disk\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+#ifdef _VISUALCPP
+					if (curdiskp->fldrn>=0){
+						PRINTF_ERR("disk%u: chosen filesystem is incompatible with floppy\n",curdiskp->index);
+						goto main_parser_next;
+					}
+#endif /* _VISUALCPP */
+					if (blk_cache_enable){ /* cache enabled? */
+						flush_blk_cache(); /* XXX if error, maybe next time more luck */
+					}
+
+					/* total size to format */
+					if (cmdtoknr>=2){
+						if (strcasecmp(cmdtok[1],"SH205")==0){
+							totb=AKAI_HD9_SH205SIZE;
+						}else if (strcasecmp(cmdtok[1],"SUPRA20M")==0){
+							totb=AKAI_HD9_SUPRA20MSIZE;
+						}else if (strcasecmp(cmdtok[1],"SUPRA30M")==0){
+							totb=AKAI_HD9_SUPRA30MSIZE;
+						}else if (strcasecmp(cmdtok[1],"SUPRA60M")==0){
+							totb=AKAI_HD9_SUPRA60MSIZE;
+						}else{
+							l=(u_int)strlen(cmdtok[1]);
+							if ((l>=1)&&((cmdtok[1][l-1]=='M')||(cmdtok[1][l-1]=='m'))){ /* in MB? */
+								cmdtok[1][l-1]='\0'; /* XXX remove letter */
+								l=(1024*1024)/AKAI_HD_BLOCKSIZE; /* MB */
+							}else{
+								l=1; /* block */
+							}
+							totb=l*(u_int)atoi(cmdtok[1]);
+						}
+					}else{
+						totb=AKAI_HD9_MAXSIZE; /* maximum */
+					}
+					/* Note: akai_wipe_harddisk9() will truncate totb if required */
+
+					/* create filesystem */
+					PRINTF_OUT("\ncreating filesystem on disk%u\n",curdiskp->index);
+					FLUSH_ALL;
+					ret=akai_wipe_harddisk9(curdiskp,totb);
+					/* Note: blksize might have changed now!!! */
+					if (ret!=0){
+						PRINTF_ERR("format error\n");
+						FLUSH_ALL;
+					}
+					if (ret<0){ /* non-fatal? */
+						goto main_parser_next;
+					}
+					/* must exit (or restart) now!!! */
+					if (ret>0){ /* fatal? */
+						mainret=1; /* error */
+						goto main_exit;
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("\nrestarting program\n\n");
+					restartflag=1;
+					goto main_restart;
+				}
+				break;
+			case CMD_FORMATHARDDISK1:
+			case CMD_FORMATHARDDISK3:
+			case CMD_FORMATHARDDISK3CD:
+				{
+					u_int l,bsize,totb;
+					int s3000flag;
+					int cdromflag;
+					int ret;
+
+					if (curdiskp==NULL){
+						PRINTF_ERR("must be on a disk\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+#ifdef _VISUALCPP
+					if (curdiskp->fldrn>=0){
+						PRINTF_ERR("disk%u: chosen filesystem is incompatible with floppy\n",curdiskp->index);
+						goto main_parser_next;
+					}
+#endif /* _VISUALCPP */
+					if (blk_cache_enable){ /* cache enabled? */
+						flush_blk_cache(); /* XXX if error, maybe next time more luck */
+					}
+
+					/* partition size */
+					if (cmdtoknr>=2){
+						l=(u_int)strlen(cmdtok[1]);
+						if ((l>=1)&&((cmdtok[1][l-1]=='M')||(cmdtok[1][l-1]=='m'))){ /* in MB? */
+							cmdtok[1][l-1]='\0'; /* XXX remove letter */
+							l=(1024*1024)/AKAI_HD_BLOCKSIZE; /* MB */
+						}else{
+							l=1; /* block */
+						}
+						bsize=l*(u_int)atoi(cmdtok[1]);
+					}else{
+						bsize=AKAI_PART_MAXSIZE; /* maximum */
+					}
+					/* Note: akai_wipe_harddisk() will truncate bsize if required */
+					/* total size to format */
+					if (cmdtoknr>=3){
+						l=(u_int)strlen(cmdtok[2]);
+						if ((l>=1)&&((cmdtok[2][l-1]=='M')||(cmdtok[2][l-1]=='m'))){ /* in MB? */
+							cmdtok[2][l-1]='\0'; /* XXX remove letter */
+							l=(1024*1024)/AKAI_HD_BLOCKSIZE; /* MB */
+						}else{
+							l=1; /* block */
+						}
+						totb=l*(u_int)atoi(cmdtok[2]);
+					}else{
+						totb=AKAI_HD_MAXSIZE; /* maximum */
+					}
+					/* Note: akai_wipe_harddisk() will truncate totb if required */
+					if (cmdnr==CMD_FORMATHARDDISK3){
+						s3000flag=1;
+						cdromflag=0;
+					}else if (cmdnr==CMD_FORMATHARDDISK3CD){
+						s3000flag=1;
+						cdromflag=1;
+					}else{
+						s3000flag=0;
+						cdromflag=0;
+					}
+					/* create filesystem */
+					PRINTF_OUT("\ncreating filesystem on disk%u\n",curdiskp->index);
+					FLUSH_ALL;
+					ret=akai_wipe_harddisk(curdiskp,bsize,totb,s3000flag,cdromflag);
+					/* Note: blksize might have changed now!!! */
+					if (ret!=0){
+						PRINTF_ERR("format error\n");
+						FLUSH_ALL;
+					}
+					if (ret<0){ /* non-fatal? */
+						goto main_parser_next;
+					}
+					/* must exit (or restart) now!!! */
+					if (ret>0){ /* fatal? */
+						mainret=1; /* error */
+						goto main_exit;
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("\nrestarting program\n\n");
+					restartflag=1;
+					goto main_restart;
+				}
+				break;
+			case CMD_WIPEPART:
+			case CMD_WIPEPART3CD:
+			case CMD_FIXPART:
+				{
+					int wipeflag;
+					int cdromflag;
+
+					/* Note: allow invalid partition to be fixed/wiped!!! */
+					save_curdir(1); /* 1: could be modifications */
+					if (cmdtoknr>=2){
+						if (change_curdir(cmdtok[1],0,NULL,0)<0){ /* NULL,0: don't check last */
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnopart()){ /* not on partition level (sampler or DD)? */
+							PRINTF_ERR("must be a partition\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}else{
+						if ((curdiskp==NULL)||(curpartp==NULL)){
+							PRINTF_ERR("must be inside a partition\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}
+					if ((curpartp->type==PART_TYPE_FLL)||(curpartp->type==PART_TYPE_FLH)){ /* floppy? */
+						PRINTF_ERR("must not be a floppy\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (cmdnr==CMD_WIPEPART){
+						wipeflag=1;
+						cdromflag=0;
+					}else if (cmdnr==CMD_WIPEPART3CD){
+						wipeflag=1;
+						cdromflag=1;
+					}else{
+						wipeflag=0;
+						cdromflag=0;
+					}
+
+					/* create or fix filesystem, supply part[] to fix partition table if necessary */
+					PRINTF_OUT("\n%s filesystem in disk%u partition %c\n",
+								wipeflag?"creating":"fixing",curdiskp->index,curpartp->letter);
+					if (akai_wipe_part(curpartp,wipeflag,&part[0],part_num,cdromflag)<0){
+						PRINTF_ERR("failed\n");
+					}
+					if (cmdnr==CMD_WIPEPART3CD){
+						/* XXX init tags (checked by cdinfo) */
+						akai_rename_tag(curpartp,NULL,0,1); /* 1: wipe */
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_FIXHARDDISK:
+				{
+					u_int pi;
+
+					/* Note: allow invalid disk to be fixed!!! */
+					save_curdir(1); /* 1: could be modifications */
+					if (cmdtoknr>=2){
+						if (change_curdir(cmdtok[1],0,NULL,0)<0){ /* NULL,0: don't check last */
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}
+					if (curdiskp==NULL){
+						PRINTF_ERR("must be on a disk\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if ((curdiskp->type==DISK_TYPE_FLL)||(curdiskp->type==DISK_TYPE_FLH)){ /* floppy? */
+						PRINTF_ERR("must not be a floppy\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+
+					/* fix filesystem */
+					PRINTF_OUT("\nfixing filesystem on disk%u\n",curdiskp->index);
+					/* scan partitions */
+					for (pi=0;pi<part_num;pi++){
+						if (part[pi].diskp!=curdiskp){ /* not on same disk? */
+							continue; /* next partition */
+						}
+						if (part[pi].type==PART_TYPE_DD){
+							continue; /* next partition */
+						}
+						/* Note: allow invalid partitions to be fixed */
+						/* fix partition, supply part[] to fix partition table if necessary */
+						if (akai_wipe_part(&part[pi],0,&part[0],part_num,0)<0){ /* 0: fix only */
+							PRINTF_ERR("cannot fix filesystem in partition %c\n",part[pi].letter);
+							/* XXX ignore, continue with others */
+						}
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_SCANBADBLKSPART:
+			case CMD_MARKBADBLKSPART:
+				{
+					save_curdir(1); /* 1: could be modifications */
+					if (cmdtoknr>=2){
+						if (change_curdir(cmdtok[1],0,NULL,0)<0){ /* NULL,0: don't check last */
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnopart()){ /* not on partition level (sampler or DD)? */
+							PRINTF_ERR("must be a partition\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}else{
+						if ((curdiskp==NULL)||(curpartp==NULL)){
+							PRINTF_ERR("must be inside a partition\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}
+					if ((cmdnr==CMD_MARKBADBLKSPART)&&(curdiskp->readonly)){
+						PRINTF_ERR("disk%u: read-only, cannot mark bad blocks/clusters\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* scan for bad blocks/clusters */
+					if (curpartp->type==PART_TYPE_DD){
+						PRINTF_OUT("\nscanning for bad clusters\n");
+					}else{
+						PRINTF_OUT("\nscanning for bad blocks\n");
+					}
+					if (akai_scanbad(curpartp,cmdnr==CMD_MARKBADBLKSPART)<0){
+						PRINTF_OUT("invalid partition\n");
+					}else{
+						PRINTF_OUT("\rdone                           \n");
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_SCANBADBLKSDISK:
+			case CMD_MARKBADBLKSDISK:
+				{
+					u_int pi,pnr;
+
+					save_curdir(1); /* 1: could be modifications */
+					if (cmdtoknr>=2){
+						if (change_curdir(cmdtok[1],0,NULL,0)<0){ /* NULL,0: don't check last */
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}
+					if (curdiskp==NULL){
+						PRINTF_ERR("must be on a disk\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if ((cmdnr==CMD_MARKBADBLKSDISK)&&(curdiskp->readonly)){
+						PRINTF_ERR("disk%u: read-only, cannot mark bad blocks/clusters\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					for (pi=0,pnr=0;pi<part_num;pi++){
+						if (part[pi].diskp!=curdiskp){ /* not on same disk? */
+							continue; /* next partition */
+						}
+						/* scan for bad blocks/clusters */
+						if (part[pi].type==PART_TYPE_DD){
+							PRINTF_OUT("\nscanning for bad clusters in /disk%u/DD\n",curdiskp->index);
+							if (part[pi].letter!=0){
+								PRINTF_OUT("%u",(u_int)part[pi].letter);
+							}
+						}else{
+							PRINTF_OUT("\nscanning for bad blocks in /disk%u/%c\n",curdiskp->index,part[pi].letter);
+						}
+						if (akai_scanbad(&part[pi],cmdnr==CMD_MARKBADBLKSDISK)<0){
+							PRINTF_OUT("invalid partition\n");
+						}else{
+							PRINTF_OUT("\rdone                           \n");
+						}
+						pnr++;
+					}
+					if (pnr==0){
+						PRINTF_OUT("\ndisk%u: no partitions\n",curdiskp->index);
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_GETDISK:
+				{
+					int outfd;
+					u_int blk;
+					u_char fbuf[AKAI_HD_BLOCKSIZE];
+
+					save_curdir(1); /* 1: could be modifications */
+					if (curdiskp==NULL){
+						PRINTF_ERR("must be on a disk\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* create external file */
+					if ((outfd=OPEN(cmdtok[1],O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+						PERROR("open");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* export */
+					PRINTF_OUT("\n");
+					/* Note: possible error in akai_io_blks() below is ignored */
+					/*       -> should remove current content of buffers first */
+					bzero(fbuf,curdiskp->blksize);
+#ifdef _VISUALCPP
+					if (curdiskp->fldrn>=0){ /* is floppy drive? */
+						bzero(fldr_secbuf,AKAI_FL_SECSIZE);
+					}
+#endif /* _VISUALCPP */
+					for (blk=0;blk<curdiskp->bsize;blk++){
+						print_progressbar(curdiskp->bsize,blk);
+#ifdef _VISUALCPP
+						/* check if floppy drive but no floppy inserted */
+						if ((curdiskp->fldrn>=0)&&(fldr_checkfloppyinserted(curdiskp->fldrn)!=0)){
+							PRINTF_ERR("error: no floppy inserted\n\n");
+							break;
+						}
+#endif /* _VISUALCPP */
+						/* read block */
+						if (io_blks(curdiskp->fd,
+#ifdef _VISUALCPP
+									curdiskp->fldrn,
+#endif /* _VISUALCPP */
+									curdiskp->startoff,
+									fbuf,
+									blk,
+									1,
+									curdiskp->blksize,
+									0,IO_BLKS_READ)<0){ /* 0: don't alloc cache */
+#if 1
+							/* Note: error -> fbuf could contain leftover */
+							PRINTF_ERR("\nerror in block 0x%08x\n\n",blk);
+							FLUSH_ALL;
+							print_progressbar(curdiskp->bsize,0); /* 0: draw scale again */
+							if (blk>0){
+								print_progressbar(curdiskp->bsize,blk); /* draw dots again */
+							}
+							/* XXX ignore error, write current fbuf */
+#else
+							break;
+#endif
+						}
+						/* write block */
+						if (WRITE(outfd,fbuf,curdiskp->blksize)!=(int)curdiskp->blksize){
+							PERROR("write");
+							break;
+						}
+						if ((blk+1)>=curdiskp->bsize){ /* end? */
+							PRINTF_OUT("."); /* dot for 100% */
+						}
+					}
+					PRINTF_OUT("\n\n");
+					CLOSE(outfd);
+					restore_curdir();
+				}
+				break;
+			case CMD_PUTDISK:
+				{
+					int ret;
+					int inpfd;
+					struct stat instat;
+					u_int size,bsize;
+					u_int blk;
+					u_char fbuf[AKAI_HD_BLOCKSIZE];
+
+					if (blk_cache_enable){ /* cache enabled? */
+						flush_blk_cache(); /* XXX if error, maybe next time more luck */
+					}
+
+					save_curdir(1); /* 1: could be modifications */
+					if (curdiskp==NULL){
+						PRINTF_ERR("must be on a disk\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* open external file */
+					if ((inpfd=akai_openreadonly_extfile(cmdtok[1]))<0){
+						PERROR("open");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* get file size */
+					if (fstat(inpfd,&instat)<0){
+						PERROR("stat");
+						CLOSE(inpfd);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					size=(u_int)instat.st_size; /* size in bytes */
+					/* check blocksize */
+					if (curdiskp->blksize==0){
+						if ((curdiskp->type==DISK_TYPE_HD9)||(curdiskp->type==DISK_TYPE_HD)){
+							curdiskp->blksize=AKAI_HD_BLOCKSIZE; /* XXX */
+						}else{
+							curdiskp->blksize=AKAI_FL_BLOCKSIZE; /* XXX */
+						}
+					}
+					bsize=size/curdiskp->blksize; /* size in blocks, round down (blksize>0 see above) */
+					/* check bsize */
+					if (bsize>curdiskp->bsize){
+						bsize=curdiskp->bsize;
+						PRINTF_ERR("truncated to disk size\n");
+						FLUSH_ALL;
+					}
+					curdiskp->bsize=bsize; /* new partition size */
+					/* import */
+					ret=0;
+					PRINTF_OUT("\n");
+					for (blk=0;blk<curdiskp->bsize;blk++){
+						print_progressbar(curdiskp->bsize,blk);
+						/* read block */
+						if (READ(inpfd,fbuf,curdiskp->blksize)!=(int)curdiskp->blksize){
+							PERROR("read");
+							ret=1;
+							break;
+						}
+						/* write block */
+						if (io_blks(curdiskp->fd,
+#ifdef _VISUALCPP
+									curdiskp->fldrn,
+#endif /* _VISUALCPP */
+									curdiskp->startoff,
+									fbuf,
+									blk,
+									1,
+									curdiskp->blksize,
+									0,IO_BLKS_WRITE)<0){ /* 0: don't alloc cache */
+							ret=1;
+							break;
+						}
+						if ((blk+1)>=curdiskp->bsize){ /* end? */
+							PRINTF_OUT("."); /* dot for 100% */
+						}
+					}
+					PRINTF_OUT("\n\n");
+					CLOSE(inpfd);
+
+					/* must exit (or restart) now!!! */
+					if (ret>0){ /* fatal? */
+						mainret=1; /* error */
+						goto main_exit;
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("\nrestarting program\n\n");
+					restartflag=1;
+					goto main_restart;
+				}
+				break;
+			case CMD_GETPART:
+				{
+					int outfd;
+					u_int blk;
+					u_char fbuf[AKAI_HD_BLOCKSIZE];
+					char *fname;
+
+					/* Note: allow invalid partition to be exported!!! */
+					save_curdir(1); /* 1: could be modifications */
+					if (cmdtoknr>=3){
+						if (change_curdir(cmdtok[1],0,NULL,0)<0){ /* NULL,0: don't check last */
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnopart()){ /* not on partition level (sampler or DD)? */
+							PRINTF_ERR("must be a partition\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}else{
+						if ((curdiskp==NULL)||(curpartp==NULL)){
+							PRINTF_ERR("must be inside a partition\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}
+					/* create external file */
+					if (cmdtoknr>=3){
+						fname=cmdtok[2];
+					}else{
+						fname=cmdtok[1];
+					}
+					if ((outfd=OPEN(fname,O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+						PERROR("open");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* export */
+					PRINTF_OUT("\n");
+					/* Note: possible error in akai_io_blks() below is ignored */
+					/*       -> should remove current content of buffers first */
+					bzero(fbuf,curdiskp->blksize);
+#ifdef _VISUALCPP
+					if (curdiskp->fldrn>=0){ /* is floppy drive? */
+						bzero(fldr_secbuf,AKAI_FL_SECSIZE);
+					}
+#endif /* _VISUALCPP */
+					for (blk=0;blk<curpartp->bsize;blk++){
+						print_progressbar(curpartp->bsize,blk);
+#ifdef _VISUALCPP
+						/* check if floppy drive but no floppy inserted */
+						if ((curdiskp->fldrn>=0)&&(fldr_checkfloppyinserted(curdiskp->fldrn)!=0)){
+							PRINTF_ERR("error: no floppy inserted\n\n");
+							break;
+						}
+#endif /* _VISUALCPP */
+						/* read block */
+						if (akai_io_blks(curpartp,fbuf,
+										 blk,
+										 1,
+										 0,IO_BLKS_READ)<0){ /* 0: don't alloc cache */
+#if 1
+							/* Note: error -> fbuf could contain leftover */
+							PRINTF_ERR("\nerror in block 0x%08x\n\n",blk);
+							FLUSH_ALL;
+							print_progressbar(curpartp->bsize,0); /* 0: draw scale again */
+							if (blk>0){
+								print_progressbar(curpartp->bsize,blk); /* draw dots again */
+							}
+							/* XXX ignore error, write current fbuf */
+#else
+							break;
+#endif
+						}
+						/* write block */
+						if (WRITE(outfd,fbuf,curpartp->blksize)!=(int)curpartp->blksize){
+							PERROR("write");
+							break;
+						}
+						if ((blk+1)>=curpartp->bsize){ /* end? */
+							PRINTF_OUT("."); /* dot for 100% */
+						}
+					}
+					PRINTF_OUT("\n\n");
+					CLOSE(outfd);
+					restore_curdir();
+				}
+				break;
+			case CMD_PUTPART:
+				{
+					int ret;
+					int inpfd;
+					struct stat instat;
+					u_int size,bsize;
+					u_int blk;
+					u_char fbuf[AKAI_HD_BLOCKSIZE];
+					struct akai_parthead_s tmppart;
+
+					if (blk_cache_enable){ /* cache enabled? */
+						flush_blk_cache(); /* XXX if error, maybe next time more luck */
+					}
+
+					/* Note: allow import to invalid partition!!! */
+					save_curdir(1); /* 1: could be modifications */
+					if (cmdtoknr>=3){
+						if (change_curdir(cmdtok[2],0,NULL,0)<0){ /* NULL,0: don't check last */
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnopart()){ /* not on partition level (sampler or DD)? */
+							PRINTF_ERR("must be a partition\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}else{
+						if ((curdiskp==NULL)||(curpartp==NULL)){
+							PRINTF_ERR("must be inside a partition\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curpartp->bstart>curdiskp->bsize){
+						PRINTF_ERR("invalid partition start\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* open external file */
+					if ((inpfd=akai_openreadonly_extfile(cmdtok[1]))<0){
+						PERROR("open");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					/* get file size */
+					if (fstat(inpfd,&instat)<0){
+						PERROR("stat");
+						CLOSE(inpfd);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					size=(u_int)instat.st_size; /* size in bytes */
+					/* check blocksize */
+					if (curpartp->blksize==0){
+						if ((curdiskp->type==DISK_TYPE_HD9)||(curdiskp->type==DISK_TYPE_HD)){
+							curdiskp->blksize=AKAI_HD_BLOCKSIZE; /* XXX */
+						}else{
+							curdiskp->blksize=AKAI_FL_BLOCKSIZE; /* XXX */
+						}
+						curpartp->blksize=curdiskp->blksize;
+					}
+					bsize=size/curpartp->blksize; /* size in blocks, round down (blksize>0 see above) */
+					/* check bsize */
+					if ((curdiskp->type==DISK_TYPE_FLL)&&(bsize>AKAI_FLL_SIZE)){
+						bsize=AKAI_FLL_SIZE;
+						PRINTF_ERR("truncated to max. partition size\n");
+					}else if ((curdiskp->type==DISK_TYPE_FLH)&&(bsize>AKAI_FLH_SIZE)){
+						bsize=AKAI_FLH_SIZE;
+						PRINTF_ERR("truncated to max. partition size\n");
+					}else if ((curdiskp->type==DISK_TYPE_HD9)&&(bsize>AKAI_HD9_MAXSIZE)){
+						bsize=AKAI_HD9_MAXSIZE;
+						PRINTF_ERR("truncated to max. partition size\n");
+					}else if ((curdiskp->type==DISK_TYPE_HD)&&(bsize>AKAI_PART_MAXSIZE)){
+						bsize=AKAI_PART_MAXSIZE;
+						PRINTF_ERR("truncated to max. partition size\n");
+					}
+					if (curpartp->bstart+bsize>curdiskp->bsize){
+						bsize=curdiskp->bsize-curpartp->bstart;
+						PRINTF_ERR("truncated to remaining disk size\n");
+					}
+					if (bsize>curpartp->bsize){
+#if 1
+						PRINTF_ERR("import larger than current partition size, ignored\n");
+#else
+						bsize=pp->bsize;
+						PRINTF_ERR("truncated to current partition size\n");
+#endif
+					}
+					FLUSH_ALL;
+					curpartp->bsize=bsize; /* new partition size */
+					/* import */
+					ret=0;
+					PRINTF_OUT("\n");
+					for (blk=0;blk<curpartp->bsize;blk++){
+						print_progressbar(curpartp->bsize,blk);
+#if 1
+						if ((curpartp->type==PART_TYPE_HD)&&(curpartp->index==0) /* first partition on S1000/S3000 harddisk? */
+							&&(blk==0)&&(curpartp->bsize>=AKAI_PARTHEAD_BLKS)){ /* in header? */
+							/* read partition header */
+							if (READ(inpfd,(u_char *)&tmppart,AKAI_PARTHEAD_BLKS*curpartp->blksize)
+								!=(int)(AKAI_PARTHEAD_BLKS*curpartp->blksize)){
+									PERROR("read");
+									ret=1;
+									break;
+							}
+							/* transfer partition table */
+							bcopy(&(curpartp->head.hd.parttab),
+								  &(tmppart.parttab),
+								  sizeof(struct akai_parttab_s));
+							/* write partition header */
+							if (akai_io_blks(curpartp,(u_char *)&tmppart,
+											 0, /* partition header block */
+											 AKAI_PARTHEAD_BLKS,
+											 0,IO_BLKS_WRITE)<0){ /* 0: don't alloc cache */
+								ret=1;
+								break;
+							}
+							blk=AKAI_PARTHEAD_BLKS-1;
+							continue;
+						}
+#endif
+						/* read block */
+						if (READ(inpfd,fbuf,curpartp->blksize)!=(int)curpartp->blksize){
+							PERROR("read");
+							ret=1;
+							break;
+						}
+						/* write block */
+						if (akai_io_blks(curpartp,fbuf,
+										 blk,
+										 1,
+										 0,IO_BLKS_WRITE)<0){ /* 0: don't alloc cache */
+							ret=1;
+							break;
+						}
+						if ((blk+1)>=curpartp->bsize){ /* end? */
+							PRINTF_OUT("."); /* dot for 100% */
+						}
+					}
+					PRINTF_OUT("\n\n");
+					CLOSE(inpfd);
+
+					/* must exit (or restart) now!!! */
+					if (ret>0){ /* fatal? */
+						mainret=1; /* error */
+						goto main_exit;
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("\nrestarting program\n\n");
+					restartflag=1;
+					goto main_restart;
+				}
+				break;
+			case CMD_GETTAGS:
+				{
+					int outfd;
+					u_int size;
+
+					if ((curdiskp==NULL)||(curpartp==NULL)||(curpartp->type!=PART_TYPE_HD)){
+						PRINTF_ERR("must be inside an S1000/S3000 harddisk sampler partition\n");
+						goto main_parser_next;
+					}
+					if (strncmp(AKAI_PARTHEAD_TAGSMAGIC,(char *)curpartp->head.hd.tagsmagic,4)!=0){
+						PRINTF_ERR("no tags in partition\n");
+						goto main_parser_next;
+					}
+					/* create external file */
+					if ((outfd=OPEN(cmdtok[1],O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+						PERROR("open");
+						goto main_parser_next;
+					}
+					/* export tags-file */
+					size=4+AKAI_PARTHEAD_TAGNUM*AKAI_NAME_LEN; /* tags magic and tag names */;
+					if (WRITE(outfd,(void *)curpartp->head.hd.tagsmagic,size)!=(int)size){
+						PERROR("write");
+					}
+					CLOSE(outfd);
+				}
+				break;
+			case CMD_PUTTAGS:
+				{
+					int inpfd;
+					struct stat instat;
+					u_int size;
+
+					if ((curdiskp==NULL)||(curpartp==NULL)||(curpartp->type!=PART_TYPE_HD)){
+						PRINTF_ERR("must be inside an S1000/S3000 harddisk sampler partition\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* open external file */
+					if ((inpfd=akai_openreadonly_extfile(cmdtok[1]))<0){
+						PERROR("open");
+						goto main_parser_next;
+					}
+					/* get file size */
+					if (fstat(inpfd,&instat)<0){
+						PERROR("stat");
+						CLOSE(inpfd);
+						goto main_parser_next;
+					}
+					size=(u_int)instat.st_size;
+					if (size!=(4+AKAI_PARTHEAD_TAGNUM*AKAI_NAME_LEN)){ /* invalid file size? (Note: tags magic and tag names) */
+						PRINTF_ERR("invalid file size of tags-file\n");
+						CLOSE(inpfd);
+						goto main_parser_next;
+					}
+					/* read tags-file into partition header */
+					if (READ(inpfd,(void *)curpartp->head.hd.tagsmagic,size)!=(int)size){
+						PERROR("read");
+						CLOSE(inpfd);
+						goto main_parser_next;
+					}
+					CLOSE(inpfd);
+					/* XXX no check if valid tags magic */
+					/* write partition header */
+					if (akai_io_blks(curpartp,(u_char *)&curpartp->head.hd,
+									 0,
+									 AKAI_PARTHEAD_BLKS,
+									 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+						PRINTF_ERR("cannot write partition header\n");
+						goto main_parser_next;
+					}
+					PRINTF_OUT("tags imported\n");
+				}
+				break;
+			case CMD_RENVOL:
+			case CMD_RENVOLI:
+				{
+					struct vol_s *vp;
+					struct vol_s tmpvol;
+					u_int vi;
+
+					if ((strcmp(cmdtok[2],".")==0)||(strcmp(cmdtok[2],"..")==0)){
+						PRINTF_ERR("invalid volume name\n");
+						goto main_parser_next;
+					}
+
+					/* Note: allow invalid volume to be renamed!!! */
+					if (cmdnr==CMD_RENVOL){
+						save_curdir(1); /* 1: could be modifications */
+						if (change_curdir(cmdtok[1],0,NULL,0)<0){ /* NULL,0: don't check last */
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be a volume\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						vp=curvolp;
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on sampler partition level\n");
+							goto main_parser_next;
+						}
+						/* index */
+						vi=(u_int)atoi(cmdtok[1]);
+						if ((vi<1)||(vi>curpartp->volnummax)){
+							PRINTF_ERR("invalid volume index\n");
+							goto main_parser_next;
+						}
+						/* find volume in current partition */
+						if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+							PRINTF_ERR("volume not found\n");
+							goto main_parser_next;
+						}
+						vp=&tmpvol;
+					}
+#if 1
+					if (curpartp!=NULL){
+						struct vol_s tmpvol2;
+
+						/* check if new volume name already used */
+						if (akai_find_vol(curpartp,&tmpvol2,cmdtok[2])==0){
+							PRINTF_ERR("volume name already used\n");
+							if (cmdnr==CMD_RENVOL){
+								restore_curdir();
+							}
+							goto main_parser_next;
+						}
+					}
+#endif
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						if (cmdnr==CMD_RENVOL){
+							restore_curdir();
+						}
+						goto main_parser_next;
+					}
+					/* rename volume */
+					if (akai_rename_vol(vp,cmdtok[2],vp->lnum,vp->osver,NULL)<0){
+						PRINTF_ERR("rename error\n");
+					}
+					if (cmdnr==CMD_RENVOL){
+						restore_curdir();
+					}
+				}
+				break;
+			case CMD_SETOSVERVOL:
+			case CMD_SETOSVERVOLI:
+				{
+					struct vol_s *vp;
+					struct vol_s tmpvol;
+					u_int vi;
+					char *osvername;
+					u_int osver;
+
+					if (cmdnr==CMD_SETOSVERVOL){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						if ((curpartp->type==PART_TYPE_HD9)||(curpartp->type==PART_TYPE_HD)
+							||(curvolp->type==AKAI_VOL_TYPE_S900)){
+							PRINTF_ERR("must be an S1000/S3000 floppy volume\n");
+							goto main_parser_next;
+						}
+						vp=curvolp;
+						osvername=cmdtok[1];
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on sampler partition level\n");
+							goto main_parser_next;
+						}
+						if ((curpartp->type==PART_TYPE_HD9)||(curpartp->type==PART_TYPE_HD)
+							||(curvolp->type==AKAI_VOL_TYPE_S900)){
+							PRINTF_ERR("must be an S1000/S3000 floppy volume\n");
+							goto main_parser_next;
+						}
+						/* index */
+						vi=(u_int)atoi(cmdtok[1]);
+						if ((vi<1)||(vi>curpartp->volnummax)){
+							PRINTF_ERR("invalid volume index\n");
+							goto main_parser_next;
+						}
+						/* find volume in current partition */
+						if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+							PRINTF_ERR("volume not found\n");
+							goto main_parser_next;
+						}
+						vp=&tmpvol;
+						osvername=cmdtok[2];
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* OS version */
+					if (strstr(osvername,".")!=NULL){
+						/* format: "XX.XX" */
+						osver=(u_int)(100.0*atof(osvername));
+						osver=(((osver/100))<<8)|(osver%100);
+					}else{
+						/* integer format */
+						osver=(u_int)atoi(osvername);
+					}
+					/* set OS version in volume */
+					/* Note: akai_rename_file() will correct osver if necessary */
+					if (akai_rename_vol(vp,NULL,vp->lnum,osver,NULL)<0){
+						PRINTF_ERR("cannot set OS version\n");
+					}
+				}
+				break;
+			case CMD_SETLNUM:
+			case CMD_SETLNUMI:
+				{
+					struct vol_s *vp;
+					struct vol_s tmpvol;
+					u_int vi;
+					char *lnumname;
+					u_int lnum;
+
+					if (cmdnr==CMD_SETLNUM){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						if (curpartp->type!=PART_TYPE_HD){
+							PRINTF_ERR("must be an S1000/S3000 harddisk volume\n");
+							goto main_parser_next;
+						}
+						vp=curvolp;
+						lnumname=cmdtok[1];
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on sampler partition level\n");
+							goto main_parser_next;
+						}
+						if (curpartp->type!=PART_TYPE_HD){
+							PRINTF_ERR("must be an S1000/S3000 harddisk volume\n");
+							goto main_parser_next;
+						}
+						/* index */
+						vi=(u_int)atoi(cmdtok[1]);
+						if ((vi<1)||(vi>curpartp->volnummax)){
+							PRINTF_ERR("invalid volume index\n");
+							goto main_parser_next;
+						}
+						/* find volume in current partition */
+						if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+							PRINTF_ERR("volume not found\n");
+							goto main_parser_next;
+						}
+						vp=&tmpvol;
+						lnumname=cmdtok[2];
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* load number */
+					lnum=akai_get_lnum(lnumname);
+					/* set load number in volume */
+					if (akai_rename_vol(vp,NULL,lnum,vp->osver,NULL)<0){
+						PRINTF_ERR("cannot set load number\n");
+					}
+				}
+				break;
+			case CMD_LSPARAM:
+			case CMD_LSPARAMI:
+				{
+					struct vol_s *vp;
+					struct vol_s tmpvol;
+					u_int vi;
+
+					if (cmdnr==CMD_LSPARAM){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						vp=curvolp;
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on sampler partition level\n");
+							goto main_parser_next;
+						}
+						/* index */
+						vi=(u_int)atoi(cmdtok[1]);
+						if ((vi<1)||(vi>curpartp->volnummax)){
+							PRINTF_ERR("invalid volume index\n");
+							goto main_parser_next;
+						}
+						/* find volume in current partition */
+						if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+							PRINTF_ERR("volume not found\n");
+							goto main_parser_next;
+						}
+						vp=&tmpvol;
+					}
+					if (vp->param!=NULL){
+						PRINTF_OUT("\n");
+						akai_list_volparam(vp->param,1); /* 1: list parameter values */
+						PRINTF_OUT("\n");
+					}else{
+						PRINTF_ERR("volume has no parameters\n");
+					}
+				}
+				break;
+			case CMD_INITPARAM:
+			case CMD_INITPARAMI:
+				{
+					struct vol_s *vp;
+					struct vol_s tmpvol;
+					u_int vi;
+
+					if (cmdnr==CMD_INITPARAM){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						vp=curvolp;
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on sampler partition level\n");
+							goto main_parser_next;
+						}
+						/* index */
+						vi=(u_int)atoi(cmdtok[1]);
+						if ((vi<1)||(vi>curpartp->volnummax)){
+							PRINTF_ERR("invalid volume index\n");
+							goto main_parser_next;
+						}
+						/* find volume in current partition */
+						if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+							PRINTF_ERR("volume not found\n");
+							goto main_parser_next;
+						}
+						vp=&tmpvol;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					if (vp->param!=NULL){
+						/* default parameters */
+						akai_init_volparam(vp->param,(vp->type==AKAI_VOL_TYPE_S3000)||(vp->type==AKAI_VOL_TYPE_CD3000));
+						/* update volume */
+						if (akai_rename_vol(vp,NULL,vp->lnum,vp->osver,vp->param)<0){
+							PRINTF_ERR("cannot update volume\n");
+							goto main_parser_next;
+						}
+					}else{
+						PRINTF_ERR("volume has no parameters\n");
+					}
+				}
+				break;
+			case CMD_SETPARAM:
+			case CMD_SETPARAMI:
+				{
+					struct vol_s *vp;
+					struct vol_s tmpvol;
+					u_int vi;
+					char *piname,*pvname;
+					u_int pi,pv;
+
+					if (cmdnr==CMD_SETPARAM){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						vp=curvolp;
+						piname=cmdtok[1];
+						pvname=cmdtok[2];
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on sampler partition level\n");
+							goto main_parser_next;
+						}
+						/* index */
+						vi=(u_int)atoi(cmdtok[1]);
+						if ((vi<1)||(vi>curpartp->volnummax)){
+							PRINTF_ERR("invalid volume index\n");
+							goto main_parser_next;
+						}
+						/* find volume in current partition */
+						if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+							PRINTF_ERR("volume not found\n");
+							goto main_parser_next;
+						}
+						vp=&tmpvol;
+						piname=cmdtok[2];
+						pvname=cmdtok[3];
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					if (vp->param!=NULL){
+						/* parameter index */
+						pi=(u_int)atoi(piname);
+						if (pi>=sizeof(struct akai_volparam_s)){
+							PRINTF_ERR("invalid parameter index\n");
+							goto main_parser_next;
+						}
+						/* parameter value */
+						pv=(u_int)atoi(pvname);
+						if (pv>=0xff){
+							PRINTF_ERR("invalid parameter value\n");
+							goto main_parser_next;
+						}
+						/* set parameter */
+						((u_char *)vp->param)[pi]=(u_char)pv;
+						/* update volume */
+						if (akai_rename_vol(vp,NULL,vp->lnum,vp->osver,vp->param)<0){
+							PRINTF_ERR("cannot update volume\n");
+							goto main_parser_next;
+						}
+					}else{
+						PRINTF_ERR("volume has no parameters\n");
+					}
+				}
+				break;
+			case CMD_GETPARAM:
+			case CMD_GETPARAMI:
+				{
+					struct vol_s *vp;
+					struct vol_s tmpvol;
+					u_int vi;
+					int outfd;
+					u_int size;
+					char *fname;
+
+					if (cmdnr==CMD_GETPARAM){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						vp=curvolp;
+						fname=cmdtok[1];
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on sampler partition level\n");
+							goto main_parser_next;
+						}
+						/* index */
+						vi=(u_int)atoi(cmdtok[1]);
+						if ((vi<1)||(vi>curpartp->volnummax)){
+							PRINTF_ERR("invalid volume index\n");
+							goto main_parser_next;
+						}
+						/* find volume in current partition */
+						if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+							PRINTF_ERR("volume not found\n");
+							goto main_parser_next;
+						}
+						vp=&tmpvol;
+						fname=cmdtok[2];
+					}
+					if (vp->param!=NULL){
+						/* create external file */
+						if ((outfd=OPEN(fname,O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+							PERROR("open");
+							goto main_parser_next;
+						}
+						/* export volparam-file */
+						size=sizeof(struct akai_volparam_s);
+						if (WRITE(outfd,(void *)vp->param,size)!=(int)size){
+							PERROR("write");
+						}
+						CLOSE(outfd);
+					}else{
+						PRINTF_ERR("volume has no parameters\n");
+					}
+				}
+				break;
+			case CMD_PUTPARAM:
+			case CMD_PUTPARAMI:
+				{
+					struct vol_s *vp;
+					struct vol_s tmpvol;
+					u_int vi;
+					int inpfd;
+					struct stat instat;
+					u_int size;
+					char *fname;
+
+					if (cmdnr==CMD_PUTPARAM){
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						vp=curvolp;
+						fname=cmdtok[1];
+					}else{
+						if (check_curnosamplerpart()){ /* not on sampler partition level? */
+							PRINTF_ERR("must be on sampler partition level\n");
+							goto main_parser_next;
+						}
+						/* index */
+						vi=(u_int)atoi(cmdtok[1]);
+						if ((vi<1)||(vi>curpartp->volnummax)){
+							PRINTF_ERR("invalid volume index\n");
+							goto main_parser_next;
+						}
+						/* find volume in current partition */
+						if (akai_get_vol(curpartp,&tmpvol,vi-1)<0){
+							PRINTF_ERR("volume not found\n");
+							goto main_parser_next;
+						}
+						vp=&tmpvol;
+						fname=cmdtok[2];
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					if (vp->param!=NULL){
+						/* open external file */
+						if ((inpfd=akai_openreadonly_extfile(fname))<0){
+							PERROR("open");
+							goto main_parser_next;
+						}
+						/* get file size */
+						if (fstat(inpfd,&instat)<0){
+							PERROR("stat");
+							CLOSE(inpfd);
+							goto main_parser_next;
+						}
+						size=(u_int)instat.st_size;
+						if (size!=sizeof(struct akai_volparam_s)){ /* invalid file size? */
+							PRINTF_ERR("invalid file size of volparam-file\n");
+							CLOSE(inpfd);
+							goto main_parser_next;
+						}
+						/* read volparam-file into volume */
+						if (READ(inpfd,(void *)vp->param,size)!=(int)size){
+							PERROR("read");
+							CLOSE(inpfd);
+							goto main_parser_next;
+						}
+						CLOSE(inpfd);
+						/* update volume */
+						if (akai_rename_vol(vp,NULL,vp->lnum,vp->osver,vp->param)<0){
+							PRINTF_ERR("cannot update volume\n");
+							goto main_parser_next;
+						}
+						PRINTF_OUT("volume parameters imported\n");
+					}else{
+						PRINTF_ERR("volume has no parameters\n");
+					}
+				}
+				break;
+			case CMD_GET:
+			case CMD_GETI:
+			case CMD_SAMPLE2WAV:
+			case CMD_SAMPLE2WAVI:
+				{
+					struct file_s tmpfile;
+					struct vol_s tmpvol;
+					u_int sfi;
+					int outfd;
+					u_int begin,end;
+					char *wavname;
+
+					if ((cmdnr==CMD_GET)||(cmdnr==CMD_SAMPLE2WAV)){
+						save_curdir(0); /* 0: no modifications */
+						if (change_curdir(cmdtok[1],0,dirnamebuf,0)<0){
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be a file in a sampler volume\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if (strlen(dirnamebuf)==0){
+							PRINTF_ERR("invalid file name\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						/* find file in current directory */
+						/* must save current volume for tmpfile */
+						akai_copy_structvol(curvolp,&tmpvol);
+						if (akai_find_file(&tmpvol,&tmpfile,dirnamebuf)<0){
+							PRINTF_ERR("file not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						restore_curdir();
+					}else{
+						if (check_curnosamplervol()){ /* not inside a sampler volume? */
+							PRINTF_ERR("must be inside a volume\n");
+							goto main_parser_next;
+						}
+						/* index */
+						sfi=(u_int)atoi(cmdtok[1]);
+						if ((sfi<1)||(sfi>curvolp->fimax)){
+							PRINTF_ERR("invalid file index\n");
+							goto main_parser_next;
+						}
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,sfi-1)<0){
+							PRINTF_ERR("file not found\n");
+							goto main_parser_next;
+						}
+					}
+					PRINTF_OUT("exporting \"%s\"\n",tmpfile.name);
+					FLUSH_ALL;
+					if ((cmdnr==CMD_GET)||(cmdnr==CMD_GETI)){
+						/* create external file */
+						if ((outfd=OPEN(tmpfile.name,O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+							PERROR("open");
+							goto main_parser_next;
+						}
+						/* limits */
+						if (cmdtoknr>=3){
+							begin=(u_int)atoi(cmdtok[2]);
+						}else{
+							begin=0;
+						}
+						if (cmdtoknr>=4){
+							end=(u_int)atoi(cmdtok[3]);
+						}else{
+							end=tmpfile.size;
+						}
+						/* export file */
+						if (akai_read_file(outfd,NULL,&tmpfile,begin,end)<0){
+							PRINTF_ERR("export error\n");
+						}
+						CLOSE(outfd);
+					}else{
+						/* export file to WAV */
+#if 1
+						PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+						/* no current external WAV file */
+						curwavname[0]='\0';
+						curwavcmdbuf[0]='\0';
+#endif
+						wavname=NULL;
+						if (akai_sample2wav(&tmpfile,-1,NULL,&wavname,SAMPLE2WAV_ALL)!=0){ /* error or not valid sample file? */
+							PRINTF_ERR("cannot export file to WAV\n");
+						}
+						if ((wavname!=NULL)&&(wavname[0]!='\0')){
+							/* use name of last exported WAV file */
+							SNPRINTF(curwavname,CURWAVNAMEMAXLEN,"%s",wavname);
+							PLAYWAV_PREPARE(curwavcmdbuf,CURWAVCMDBUFSIZ,curwavname);
+						}
+					}
+				}
+				break;
+			case CMD_GETALL:
+				{
+					struct file_s tmpfile;
+					u_int sfi;
+					int outfd;
+					u_int fcount;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+					/* all files in current volume */
+					fcount=0;
+					for (sfi=0;sfi<curvolp->fimax;sfi++){
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,sfi)<0){
+							continue; /* next */
+						}
+						/* export file */
+						PRINTF_OUT("exporting \"%s\"\n",tmpfile.name);
+						FLUSH_ALL;
+						/* create external file */
+						if ((outfd=OPEN(tmpfile.name,O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+							PERROR("open");
+							goto main_parser_next;
+						}
+						/* export file */
+						if (akai_read_file(outfd,NULL,&tmpfile,0,tmpfile.size)==0){
+							fcount++;
+						}else{
+							PRINTF_ERR("export error\n");
+							/* XXX continue */
+						}
+						CLOSE(outfd);
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("exported %u file(s)\n",fcount);
+				}
+				break;
+			case CMD_SAMPLE2WAVALL:
+				{
+					struct file_s tmpfile;
+					u_int sfi;
+					u_int fcount;
+					char *wavname;
+
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("must be inside a volume\n");
+						goto main_parser_next;
+					}
+#if 1
+					PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+					/* no current external WAV file */
+					curwavname[0]='\0';
+					curwavcmdbuf[0]='\0';
+#endif
+					/* all files in current volume */
+					fcount=0;
+					wavname=NULL;
+					for (sfi=0;sfi<curvolp->fimax;sfi++){
+						/* find file in current volume */
+						if (akai_get_file(curvolp,&tmpfile,sfi)<0){
+							continue; /* next */
+						}
+						/* export file */
+						PRINTF_OUT("exporting \"%s\"\n",tmpfile.name);
+						FLUSH_ALL;
+						if (akai_sample2wav(&tmpfile,-1,NULL,&wavname,SAMPLE2WAV_ALL)==0){
+							fcount++;
+						} /* XXX else: continue */
+					}
+					if ((wavname!=NULL)&&(wavname[0]!='\0')){
+						/* use name of last exported WAV file */
+						SNPRINTF(curwavname,CURWAVNAMEMAXLEN,"%s",wavname);
+						PLAYWAV_PREPARE(curwavcmdbuf,CURWAVCMDBUFSIZ,curwavname);
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("exported %u file(s)\n",fcount);
+				}
+				break;
+			case CMD_PUT:
+				{
+					struct file_s tmpfile;
+					int inpfd;
+					struct stat instat;
+					u_int size;
+					u_int dfi;
+					u_int fcount;
+#ifdef _VISUALCPP
+					HANDLE ha;
+					WIN32_FIND_DATAA fd;
+#else /* !_VISUALCPP */
+					DIR *dp;
+					struct dirent *dep;
+#endif /* !_VISUALCPP */
+					int allflag;
+					char *name;
+
+#ifdef _VISUALCPP
+					ha=INVALID_HANDLE_VALUE;
+#else /* !_VISUALCPP */
+					dp=NULL;
+#endif /* !_VISUALCPP */
+
+					save_curdir(1); /* 1: could be modifications */
+					if (change_curdir(cmdtok[1],0,dirnamebuf,0)<0){
+						PRINTF_ERR("destination directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("destination must be inside a volume\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (strlen(dirnamebuf)==0){
+						PRINTF_ERR("invalid file name\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (cmdtoknr>=3){
+						/* index */
+						dfi=(u_int)atoi(cmdtok[2]);
+						if ((dfi<1)||(dfi>curvolp->fimax)){
+							PRINTF_ERR("invalid file index\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						/* XXX akai_create_file() below will check if index is free */
+					}else{
+						dfi=AKAI_CREATE_FILE_NOINDEX;
+					}
+					if (strcasecmp(dirnamebuf,"*")==0){
+						if (cmdtoknr>=3){
+							PRINTF_ERR("ignoring given file index\n");
+							FLUSH_ALL;
+							dfi=AKAI_CREATE_FILE_NOINDEX;
+						}
+						/* all files */
+						allflag=1;
+#ifdef _VISUALCPP
+						/* open local directory and get first directory entry */
+						ha=FindFirstFileA("*",&fd);
+						if (ha==INVALID_HANDLE_VALUE){
+							PRINTF_ERR("error: cannot read local directory\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+#else /* !_VISUALCPP */
+						/* open local directory */
+						dp=opendir(".");
+						if (dp==NULL){
+							PRINTF_ERR("error: cannot read local directory\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+#endif /* !_VISUALCPP */
+						name=NULL;
+					}else{
+						/* single WAV file */
+						allflag=0;
+						name=dirnamebuf;
+					}
+					/* import file(s) */
+					fcount=0;
+					for (;;){
+						if (allflag){
+#ifdef _VISUALCPP
+							if (name==NULL){
+								name=fd.cFileName;
+							}else{
+								/* get next directory entry */
+								if (((int)FindNextFileA(ha,&fd))==0){ /* end? */
+									break; /* done */
+								}
+							}
+							if (FILE_ATTRIBUTE_DIRECTORY&fd.dwFileAttributes){ /* directory? */
+								continue; /* next */
+							}
+#else /* !_VISUALCPP */
+							/* get next directory entry */
+							dep=readdir(dp);
+							if (dep==NULL){ /* end? */
+								break; /* done */
+							}
+							if (dep->d_type!=DT_REG){ /* not regular file? */
+								continue; /* next */
+							}
+							name=dep->d_name;
+#endif /* !_VISUALCPP */
+#if 1
+							{
+								static u_char anamebuf[AKAI_NAME_LEN+4+1]; /* +4 for ".<type>", +1 for '\0' */
+								u_int osver;
+
+								/* skip file with invalid name/type */
+								if (ascii2akai_filename(name,anamebuf,&osver,curvolp->type==AKAI_VOL_TYPE_S900)==AKAI_FTYPE_FREE){
+									PRINTF_OUT("invalid file name/type, skipping \"%s\"\n",name);
+									FLUSH_ALL;
+									continue; /* next */
+								}
+							}
+#endif
+						}
+						if (allflag){
+							PRINTF_OUT("importing \"%s\"\n",name);
+							FLUSH_ALL;
+						}
+						/* open external file */
+						if ((inpfd=akai_openreadonly_extfile(name))<0){
+							PERROR("open");
+							break; /* exit */
+						}
+						/* get file size */
+						if (fstat(inpfd,&instat)<0){
+							PERROR("stat");
+							CLOSE(inpfd);
+							break; /* exit */
+						}
+						size=(u_int)instat.st_size;
+						/* check if destination file already exists */
+						if (akai_find_file(curvolp,&tmpfile,name)==0){
+							/* exists */
+							/* delete file */
+							if (akai_delete_file(&tmpfile)<0){
+								PRINTF_ERR("cannot overwrite existing file\n");
+								CLOSE(inpfd);
+								break; /* exit */
+							}
+						}
+						/* create destination file */
+						/* Note: akai_create_file() will correct osver if necessary */
+						if (akai_create_file(curvolp,&tmpfile,size,
+											 dfi,
+											 name,
+											 (curvolp->type==AKAI_VOL_TYPE_S900)?0:curvolp->osver, /* default: from volume */
+											 NULL)<0){
+							PRINTF_ERR("cannot create file\n");
+							CLOSE(inpfd);
+							break; /* exit */
+						}
+						/* import file */
+						if (akai_write_file(inpfd,NULL,&tmpfile,0,tmpfile.size)<0){
+							PRINTF_ERR("import error\n");
+							CLOSE(inpfd);
+							break; /* exit */
+						}
+						CLOSE(inpfd);
+						if ((curvolp->type==AKAI_VOL_TYPE_S900)&&(tmpfile.osver!=0)){ /* compressed file in S900 volume? */
+							/* update uncompr value */
+							akai_s900comprfile_updateuncompr(&tmpfile); /* ignore error */
+						}
+						/* fix name in header (if necessary) */
+						akai_fixramname(&tmpfile); /* ignore error */
+						if (!allflag){
+							break; /* done */
+						}
+						fcount++;
+					}
+					restore_curdir();
+#ifdef _VISUALCPP
+					if (ha!=INVALID_HANDLE_VALUE){
+						/* close local directory */
+						FindClose(ha);
+					}
+#else /* !_VISUALCPP */
+					if (dp!=NULL){
+						/* close local directory */
+						closedir(dp);
+					}
+#endif /* !_VISUALCPP */
+					if (allflag){
+						FLUSH_ALL;
+						PRINTF_OUT("imported %u file(s)\n",fcount);
+					}
+				}
+				break;
+			case CMD_WAV2SAMPLE:
+			case CMD_WAV2SAMPLE9:
+			case CMD_WAV2SAMPLE9C:
+			case CMD_WAV2SAMPLE1:
+			case CMD_WAV2SAMPLE3:
+				{
+					u_int nlen;
+					u_int dfi;
+					u_int type;
+					u_int fcount;
+					int err;
+#ifdef _VISUALCPP
+					HANDLE ha;
+					WIN32_FIND_DATAA fd;
+#else /* !_VISUALCPP */
+					DIR *dp;
+					struct dirent *dep;
+#endif /* !_VISUALCPP */
+					int allflag;
+					char *name;
+
+#if 1
+					PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+					/* no current external WAV file */
+					curwavname[0]='\0';
+					curwavcmdbuf[0]='\0';
+#endif
+#ifdef _VISUALCPP
+					ha=INVALID_HANDLE_VALUE;
+#else /* !_VISUALCPP */
+					dp=NULL;
+#endif /* !_VISUALCPP */
+					save_curdir(1); /* 1: could be modifications */
+					if (change_curdir(cmdtok[1],0,dirnamebuf,0)<0){
+						PRINTF_ERR("destination directory not found\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (check_curnosamplervol()){ /* not inside a sampler volume? */
+						PRINTF_ERR("destination must be inside a volume\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (cmdtoknr>=3){
+						/* index */
+						dfi=(u_int)atoi(cmdtok[2]);
+						if ((dfi<1)||(dfi>curvolp->fimax)){
+							PRINTF_ERR("invalid file index\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						/* XXX akai_create_file() in akai_wav2sample() below will check if index is free */
+					}else{
+						dfi=AKAI_CREATE_FILE_NOINDEX;
+					}
+					/* sample file type */
+					if ((cmdnr==CMD_WAV2SAMPLE9)||(cmdnr==CMD_WAV2SAMPLE9C)){
+						type=AKAI_SAMPLE900_FTYPE;
+					}else if (cmdnr==CMD_WAV2SAMPLE1){
+						type=AKAI_SAMPLE1000_FTYPE;
+					}else if (cmdnr==CMD_WAV2SAMPLE3){
+						type=AKAI_SAMPLE3000_FTYPE;
+					}else{
+						type=AKAI_FTYPE_FREE; /* invalid: derive sample file type from volume type/file osver */
+					}
+					if (strcasecmp(dirnamebuf,"*.wav")==0){
+						/* all WAV files */
+						allflag=1;
+#ifdef _VISUALCPP
+						/* open local directory and get first directory entry */
+						ha=FindFirstFileA("*",&fd);
+						if (ha==INVALID_HANDLE_VALUE){
+							PRINTF_ERR("error: cannot read local directory\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+#else /* !_VISUALCPP */
+						/* open local directory */
+						dp=opendir(".");
+						if (dp==NULL){
+							PRINTF_ERR("error: cannot read local directory\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+#endif /* !_VISUALCPP */
+						name=NULL;
+					}else{
+						/* single WAV file */
+						/* check external WAV file name (and modify given file name if required) */
+						/* Note: string in dirnamebuf may be modified here */
+						if (akai_check_extwavname(dirnamebuf)<0){
+							restore_curdir();
+							goto main_parser_next;
+						}
+						allflag=0;
+						name=dirnamebuf;
+					}
+					/* import WAV file(s) */
+					fcount=0;
+					for (;;){
+						if (allflag){
+#ifdef _VISUALCPP
+							if (name==NULL){
+								name=fd.cFileName;
+							}else{
+								/* get next directory entry */
+								if (((int)FindNextFileA(ha,&fd))==0){ /* end? */
+									break; /* done */
+								}
+							}
+							if (FILE_ATTRIBUTE_DIRECTORY&fd.dwFileAttributes){ /* directory? */
+								continue; /* next */
+							}
+#else /* !_VISUALCPP */
+							/* get next directory entry */
+							dep=readdir(dp);
+							if (dep==NULL){ /* end? */
+								break; /* done */
+							}
+							if (dep->d_type!=DT_REG){ /* not regular file? */
+								continue; /* next */
+							}
+							name=dep->d_name;
+#endif /* !_VISUALCPP */
+							nlen=(u_int)strlen(name);
+							if ((nlen<4)||(strncasecmp(name+nlen-4,".wav",4)!=0)){ /* not a WAV file? */
+								continue; /* next */
+							}
+						}
+						/* read and parse WAV header, create sample header, import samples */
+						PRINTF_OUT("importing \"%s\"\n",name);
+						FLUSH_ALL;
+						/* Note: akai_wav2sample() will correct osver if necessary */
+						err=akai_wav2sample(-1,name,
+											curvolp,
+											dfi,
+											type,
+											(cmdnr==CMD_WAV2SAMPLE9C),
+											curvolp->osver, /* default: osver from volume */
+											NULL, /* no tags */
+											NULL,
+											WAV2SAMPLE_OPEN|WAV2SAMPLE_OVERWRITE);
+						FLUSH_ALL;
+						if (err<0){
+							PRINTF_ERR("WAV import error\n");
+							break; /* exit */
+						}
+						if (!allflag){
+							break; /* done */
+						}
+						if (err==0){
+							fcount++;
+						}
+					}
+					restore_curdir();
+#ifdef _VISUALCPP
+					if (ha!=INVALID_HANDLE_VALUE){
+						/* close local directory */
+						FindClose(ha);
+					}
+#else /* !_VISUALCPP */
+					if (dp!=NULL){
+						/* close local directory */
+						closedir(dp);
+					}
+#endif /* !_VISUALCPP */
+					if ((name!=NULL)&&(name[0]!='\0')){
+						/* use name of last imported WAV file */
+						SNPRINTF(curwavname,CURWAVNAMEMAXLEN,"%s",name);
+						PLAYWAV_PREPARE(curwavcmdbuf,CURWAVCMDBUFSIZ,curwavname);
+					}
+					if (allflag){
+						FLUSH_ALL;
+						PRINTF_OUT("imported %u WAV file(s)\n",fcount);
+					}
+				}
+				break;
+			case CMD_TGETI:
+				{
+					u_int ti;
+					int outfd;
+					u_int cstarts,cstarte;
+					u_int csizes,csizee;
+					struct akai_ddtake_s t;
+					char fnamebuf[AKAI_NAME_LEN+4+1]; /* name (ASCII), +4 for ".<type>", +1 for '\0' */
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					/* index */
+					ti=(u_int)atoi(cmdtok[1]);
+					if ((ti<1)||(ti>AKAI_DDTAKE_MAXNUM)){
+						PRINTF_ERR("invalid take index\n");
+						goto main_parser_next;
+					}
+					/* take */
+					if (curpartp->head.dd.take[ti-1].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+						PRINTF_ERR("take not found\n");
+						goto main_parser_next;
+					}
+					/* create external file */
+					akai2ascii_name(curpartp->head.dd.take[ti-1].name,fnamebuf,0); /* 0: not S900 */
+					strcpy(fnamebuf+strlen(fnamebuf),AKAI_DDTAKE_FNAMEEND);
+					PRINTF_OUT("exporting take %u to \"%s\"\n",ti,fnamebuf);
+					FLUSH_ALL;
+					if ((outfd=OPEN(fnamebuf,O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+						PERROR("open");
+						goto main_parser_next;
+					}
+					/* clusters */
+					cstarts=(curpartp->head.dd.take[ti-1].cstarts[1]<<8)
+						    +curpartp->head.dd.take[ti-1].cstarts[0];
+					cstarte=(curpartp->head.dd.take[ti-1].cstarte[1]<<8)
+						    +curpartp->head.dd.take[ti-1].cstarte[0];
+					/* determine csizes (sample clusters) and csizee (envelope clusters) */
+					if (cstarts!=0){ /* sample not empty? */
+						csizes=akai_count_ddfatchain(curpartp,cstarts);
+					}else{
+						csizes=0;
+					}
+					if (cstarte!=0){ /* envelope not empty? */
+						csizee=akai_count_ddfatchain(curpartp,cstarte);
+					}else{
+						csizee=0;
+					}
+					/* get DD take header (DD directory entry) */
+					bcopy(&curpartp->head.dd.take[ti-1],&t,sizeof(struct akai_ddtake_s));
+					/* XXX use cstarts/cstarte fields in DD take header for csizes/csizee */
+					t.cstarts[1]=0xff&(csizes>>8);
+					t.cstarts[0]=0xff&csizes;
+					t.cstarte[1]=0xff&(csizee>>8);
+					t.cstarte[0]=0xff&csizee;
+					/* export take */
+					if (akai_export_take(outfd,curpartp,&t,csizes,csizee,cstarts,cstarte)<0){
+						PRINTF_ERR("cannot export take\n");
+					}
+					CLOSE(outfd);
+				}
+				break;
+			case CMD_TGETALL:
+				{
+					u_int ti;
+					int outfd;
+					u_int cstarts,cstarte;
+					u_int csizes,csizee;
+					struct akai_ddtake_s t;
+					char fnamebuf[AKAI_NAME_LEN+4+1]; /* name (ASCII), +4 for ".<type>", +1 for '\0' */
+					u_int tcount;
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					/* all takes in current DD partition */
+					tcount=0;
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					/* all DD takes in current DD partition */
+					tcount=0;
+					for (ti=0;ti<AKAI_DDTAKE_MAXNUM;ti++){
+						/* take */
+						if (curpartp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+							continue; /* next */
+						}
+						/* create external file */
+						akai2ascii_name(curpartp->head.dd.take[ti].name,fnamebuf,0); /* 0: not S900 */
+						strcpy(fnamebuf+strlen(fnamebuf),AKAI_DDTAKE_FNAMEEND);
+						PRINTF_OUT("exporting take %u to \"%s\"\n",ti+1,fnamebuf);
+						FLUSH_ALL;
+						if ((outfd=OPEN(fnamebuf,O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+							PERROR("open");
+							goto main_parser_next;
+						}
+						/* clusters */
+						cstarts=(curpartp->head.dd.take[ti].cstarts[1]<<8)
+							    +curpartp->head.dd.take[ti].cstarts[0];
+						cstarte=(curpartp->head.dd.take[ti].cstarte[1]<<8)
+								+curpartp->head.dd.take[ti].cstarte[0];
+						/* determine csizes (sample clusters) and csizee (envelope clusters) */
+						if (cstarts!=0){ /* sample not empty? */
+							csizes=akai_count_ddfatchain(curpartp,cstarts);
+						}else{
+							csizes=0;
+						}
+						if (cstarte!=0){ /* envelope not empty? */
+							csizee=akai_count_ddfatchain(curpartp,cstarte);
+						}else{
+							csizee=0;
+						}
+						/* get DD take header (DD directory entry) */
+						bcopy(&curpartp->head.dd.take[ti],&t,sizeof(struct akai_ddtake_s));
+						/* XXX use cstarts/cstarte fields in DD take header for csizes/csizee */
+						t.cstarts[1]=0xff&(csizes>>8);
+						t.cstarts[0]=0xff&csizes;
+						t.cstarte[1]=0xff&(csizee>>8);
+						t.cstarte[0]=0xff&csizee;
+						/* export take */
+						if (akai_export_take(outfd,curpartp,&t,csizes,csizee,cstarts,cstarte)==0){
+							tcount++;
+						}else{
+							PRINTF_ERR("export error\n");
+							/* XXX continue */
+						}
+						CLOSE(outfd);
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("exported %u take(s)\n",tcount);
+				}
+				break;
+			case CMD_TAKE2WAVI:
+				{
+					u_int ti;
+					char *wavname;
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					/* index */
+					ti=(u_int)atoi(cmdtok[1]);
+					if ((ti<1)||(ti>AKAI_DDTAKE_MAXNUM)){
+						PRINTF_ERR("invalid take index\n");
+						goto main_parser_next;
+					}
+#if 1
+					PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+					/* no current external WAV file */
+					curwavname[0]='\0';
+					curwavcmdbuf[0]='\0';
+#endif
+					/* export take to WAV */
+					PRINTF_OUT("exporting take %u\n",ti);
+					FLUSH_ALL;
+					wavname=NULL;
+					if (akai_take2wav(curpartp,ti-1,-1,NULL,&wavname,TAKE2WAV_ALL)<0){
+						PRINTF_ERR("cannot export take to WAV\n");
+					}
+					if ((wavname!=NULL)&&(wavname[0]!='\0')){
+						/* use name of last exported WAV file */
+						SNPRINTF(curwavname,CURWAVNAMEMAXLEN,"%s",wavname);
+						PLAYWAV_PREPARE(curwavcmdbuf,CURWAVCMDBUFSIZ,curwavname);
+					}
+				}
+				break;
+			case CMD_TAKE2WAVALL:
+				{
+					u_int ti;
+					u_int tcount;
+					char *wavname;
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+#if 1
+					PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+					/* no current external WAV file */
+					curwavname[0]='\0';
+					curwavcmdbuf[0]='\0';
+#endif
+					/* all DD takes in current DD partition */
+					tcount=0;
+					wavname=NULL;
+					for (ti=0;ti<AKAI_DDTAKE_MAXNUM;ti++){
+						/* take */
+						if (curpartp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+							continue; /* next */
+						}
+						/* export take to WAV */
+						PRINTF_OUT("exporting take %u\n",ti+1);
+						FLUSH_ALL;
+						if (akai_take2wav(curpartp,ti,-1,NULL,&wavname,TAKE2WAV_ALL)==0){
+							tcount++;
+						} /* XXX else: continue */
+					}
+					if ((wavname!=NULL)&&(wavname[0]!='\0')){
+						/* use name of last exported WAV file */
+						SNPRINTF(curwavname,CURWAVNAMEMAXLEN,"%s",wavname);
+						PLAYWAV_PREPARE(curwavcmdbuf,CURWAVCMDBUFSIZ,curwavname);
+					}
+					FLUSH_ALL;
+					PRINTF_OUT("exported %u take(s)\n",tcount);
+				}
+				break;
+			case CMD_TPUT:
+				{
+					u_int nlen;
+					u_int ti;
+					int inpfd;
+					u_int csizes,csizee;
+					struct akai_ddtake_s t;
+					u_int tcount;
+#ifdef _VISUALCPP
+					HANDLE ha;
+					WIN32_FIND_DATAA fd;
+#else /* !_VISUALCPP */
+					DIR *dp;
+					struct dirent *dep;
+#endif /* !_VISUALCPP */
+					int allflag;
+					char *name;
+
+#ifdef _VISUALCPP
+					ha=INVALID_HANDLE_VALUE;
+#else /* !_VISUALCPP */
+					dp=NULL;
+#endif /* !_VISUALCPP */
+
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					if (strcasecmp(cmdtok[1],"*"AKAI_DDTAKE_FNAMEEND)==0){
+						/* all take files */
+						allflag=1;
+#ifdef _VISUALCPP
+						/* open local directory and get first directory entry */
+						ha=FindFirstFileA("*",&fd);
+						if (ha==INVALID_HANDLE_VALUE){
+							PRINTF_ERR("error: cannot read local directory\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+#else /* !_VISUALCPP */
+						/* open local directory */
+						dp=opendir(".");
+						if (dp==NULL){
+							PRINTF_ERR("error: cannot read local directory\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+#endif /* !_VISUALCPP */
+						name=NULL;
+					}else{
+						/* single take file */
+						allflag=0;
+						name=cmdtok[1];
+					}
+					/* import take(s) */
+					tcount=0;
+					for (;;){
+						if (allflag){
+#ifdef _VISUALCPP
+							if (name==NULL){
+								name=fd.cFileName;
+							}else{
+								/* get next directory entry */
+								if (((int)FindNextFileA(ha,&fd))==0){ /* end? */
+									break; /* done */
+								}
+							}
+							if (FILE_ATTRIBUTE_DIRECTORY&fd.dwFileAttributes){ /* directory? */
+								continue; /* next */
+							}
+#else /* !_VISUALCPP */
+							/* get next directory entry */
+							dep=readdir(dp);
+							if (dep==NULL){ /* end? */
+								break; /* done */
+							}
+							if (dep->d_type!=DT_REG){ /* not regular file? */
+								continue; /* next */
+							}
+							name=dep->d_name;
+#endif /* !_VISUALCPP */
+							nlen=(u_int)strlen(name);
+							if ((nlen<3)||(strncasecmp(name+nlen-3,AKAI_DDTAKE_FNAMEEND,3)!=0)){ /* not a TK file? */
+								continue; /* next */
+							}
+						}
+						/* find free index */
+						for (ti=0;ti<AKAI_DDTAKE_MAXNUM;ti++){
+							/* take */
+							if (curpartp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+								break; /* done */
+							}
+						}
+						if (ti==AKAI_DDTAKE_MAXNUM){ /* no free index? */
+							PRINTF_ERR("no free take index\n");
+							break; /* exit */
+						}
+						/* import take */
+						PRINTF_OUT("importing \"%s\" to take %u\n",name,ti+1);
+						FLUSH_ALL;
+						/* open external file */
+						if ((inpfd=akai_openreadonly_extfile(name))<0){
+							PERROR("open");
+							break; /* exit */
+						}
+						/* get DD take header (DD directory entry) */
+						if (READ(inpfd,&t,sizeof(struct akai_ddtake_s))!=(int)sizeof(struct akai_ddtake_s)){
+							PERROR("read");
+							CLOSE(inpfd);
+							break; /* exit */
+						}
+						/* get csizes (sample clusters) and csizee (envelope clusters) */
+						/* XXX use cstarts/cstarte fields in DD take header for csizes/csizee */
+						csizes=(t.cstarts[1]<<8)
+							   +t.cstarts[0];
+						csizee=(t.cstarte[1]<<8)
+							   +t.cstarte[0];
+						/* Note: akai_import_take() keeps name in DD take header */
+						/* Note: don't check if name already used, create new DD take */
+						if (akai_import_take(inpfd,curpartp,&t,ti,csizes,csizee)!=0){
+							PRINTF_ERR("import error\n");
+							CLOSE(inpfd);
+							break; /* exit */
+						}
+						CLOSE(inpfd);
+						if (!allflag){
+							break; /* done */
+						}
+						tcount++;
+					}
+#ifdef _VISUALCPP
+					if (ha!=INVALID_HANDLE_VALUE){
+						/* close local directory */
+						FindClose(ha);
+					}
+#else /* !_VISUALCPP */
+					if (dp!=NULL){
+						/* close local directory */
+						closedir(dp);
+					}
+#endif /* !_VISUALCPP */
+					if (allflag){
+						FLUSH_ALL;
+						PRINTF_OUT("imported %u take(s)\n",tcount);
+					}
+				}
+				break;
+			case CMD_WAV2TAKE:
+				{
+					u_int nlen;
+					u_int ti;
+					u_int tcount;
+					int err;
+#ifdef _VISUALCPP
+					HANDLE ha;
+					WIN32_FIND_DATAA fd;
+#else /* !_VISUALCPP */
+					DIR *dp;
+					struct dirent *dep;
+#endif /* !_VISUALCPP */
+					int allflag;
+					char *name;
+
+#if 1
+					PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+					/* no current external WAV file */
+					curwavname[0]='\0';
+					curwavcmdbuf[0]='\0';
+#endif
+#ifdef _VISUALCPP
+					ha=INVALID_HANDLE_VALUE;
+#else /* !_VISUALCPP */
+					dp=NULL;
+#endif /* !_VISUALCPP */
+					if (check_curnoddpart()){ /* not on DD partition level? */
+						PRINTF_ERR("must be inside a DD partition\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					if (strcasecmp(cmdtok[1],"*.wav")==0){
+						/* all WAV files */
+						allflag=1;
+#ifdef _VISUALCPP
+						/* open local directory and get first directory entry */
+						ha=FindFirstFileA("*",&fd);
+						if (ha==INVALID_HANDLE_VALUE){
+							PRINTF_ERR("error: cannot read local directory\n");
+							goto main_parser_next;
+						}
+#else /* !_VISUALCPP */
+						/* open local directory */
+						dp=opendir(".");
+						if (dp==NULL){
+							PRINTF_ERR("error: cannot read local directory\n");
+							goto main_parser_next;
+						}
+#endif /* !_VISUALCPP */
+						name=NULL;
+					}else{
+						/* single WAV file */
+						/* check external WAV file name (and modify given file name if required) */
+						/* Note: string in cmdtok[1] may be modified here */
+						if (akai_check_extwavname(cmdtok[1])<0){
+							goto main_parser_next;
+						}
+						allflag=0;
+						name=cmdtok[1];
+					}
+					/* import WAV file(s) */
+					tcount=0;
+					for (;;){
+						if (allflag){
+#ifdef _VISUALCPP
+							if (name==NULL){
+								name=fd.cFileName;
+							}else{
+								/* get next directory entry */
+								if (((int)FindNextFileA(ha,&fd))==0){ /* end? */
+									break; /* done */
+								}
+							}
+							if (FILE_ATTRIBUTE_DIRECTORY&fd.dwFileAttributes){ /* directory? */
+								continue; /* next */
+							}
+#else /* !_VISUALCPP */
+							/* get next directory entry */
+							dep=readdir(dp);
+							if (dep==NULL){ /* end? */
+								break; /* done */
+							}
+							if (dep->d_type!=DT_REG){ /* not regular file? */
+								continue; /* next */
+							}
+							name=dep->d_name;
+#endif /* !_VISUALCPP */
+							nlen=(u_int)strlen(name);
+							if ((nlen<4)||(strncasecmp(name+nlen-4,".wav",4)!=0)){ /* not a WAV file? */
+								continue; /* next */
+							}
+						}
+						/* find free index */
+						for (ti=0;ti<AKAI_DDTAKE_MAXNUM;ti++){
+							/* take */
+							if (curpartp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+								break; /* done */
+							}
+						}
+						if (ti==AKAI_DDTAKE_MAXNUM){ /* no free index? */
+							PRINTF_ERR("no free take index\n");
+							break; /* exit */
+						}
+						/* read and parse WAV header, create take, import samples */
+						PRINTF_OUT("importing \"%s\" to take %u\n",name,ti+1);
+						FLUSH_ALL;
+						/* Note: don't check if name already used, create new DD take */
+						err=akai_wav2take(-1,name,
+										  curpartp,
+										  ti,
+										  NULL,
+										  WAV2TAKE_OPEN);
+						FLUSH_ALL;
+						if (err<0){
+							PRINTF_ERR("WAV import error\n");
+							break; /* exit */
+						}
+						if (!allflag){
+							break; /* done */
+						}
+						if (err==0){
+							tcount++;
+						}
+					}
+#ifdef _VISUALCPP
+					if (ha!=INVALID_HANDLE_VALUE){
+						/* close local directory */
+						FindClose(ha);
+					}
+#else /* !_VISUALCPP */
+					if (dp!=NULL){
+						/* close local directory */
+						closedir(dp);
+					}
+#endif /* !_VISUALCPP */
+					if ((name!=NULL)&&(name[0]!='\0')){
+						/* use name of last imported WAV file */
+						SNPRINTF(curwavname,CURWAVNAMEMAXLEN,"%s",name);
+						PLAYWAV_PREPARE(curwavcmdbuf,CURWAVCMDBUFSIZ,curwavname);
+					}
+					if (allflag){
+						FLUSH_ALL;
+						PRINTF_OUT("imported %u WAV file(s)\n",tcount);
+					}
+				}
+				break;
+			case CMD_TARC:
+			case CMD_TARCWAV:
+				{
+					int outfd;
+					u_int flags;
+
+					/* create tar-file */
+					if ((outfd=OPEN(cmdtok[1],O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+						PERROR("open");
+						goto main_parser_next;
+					}
+					/* flags */
+					if (cmdnr==CMD_TARCWAV){
+#if 1
+						PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+						/* no current external WAV file */
+						curwavname[0]='\0';
+						curwavcmdbuf[0]='\0';
+#endif
+						flags=TAR_EXPORT_WAV;
+					}else{
+						flags=0;
+					}
+					/* export tar-file */
+					if (tar_export_curdir(outfd,1,flags)<0){ /* 1: verbose */
+						PRINTF_ERR("tar error\n");
+					}
+					if (tar_export_tailzero(outfd)<0){
+						PRINTF_ERR("tar error\n");
+					}
+					CLOSE(outfd);
+				}
+				break;
+			case CMD_TARX:
+			case CMD_TARX9:
+			case CMD_TARX1:
+			case CMD_TARX3:
+			case CMD_TARX3CD:
+			case CMD_TARXWAV:
+			case CMD_TARXWAV9:
+			case CMD_TARXWAV9C:
+			case CMD_TARXWAV1:
+			case CMD_TARXWAV3:
+				{
+					int inpfd;
+					u_int vtype;
+					u_int flags;
+
+					/* XXX check for read-only mode actually not necessary here, */
+					/*     will be checked within tar_import_curdir() */
+					if ((curdiskp!=NULL)&&curdiskp->readonly){
+							PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+							goto main_parser_next;
+					}
+					/* Note: if curdiskp==NULL: cannot check for read-only mode here */
+					/*       because different disks may have different readonly values */
+					/*       and don't know here which disk is contained within the tar-file */
+					/* open tar-file */
+					if ((inpfd=akai_openreadonly_extfile(cmdtok[1]))<0){
+						PERROR("open");
+						goto main_parser_next;
+					}
+					/* volume type */
+					if (cmdnr==CMD_TARX9){
+						vtype=AKAI_VOL_TYPE_S900; /* force to S900 */
+					}else if (cmdnr==CMD_TARX1){
+						vtype=AKAI_VOL_TYPE_S1000; /* force to S1000 */
+					}else if (cmdnr==CMD_TARX3){
+						vtype=AKAI_VOL_TYPE_S3000; /* force to S3000 or CD3000 */
+					}else if (cmdnr==CMD_TARX3CD){
+						vtype=AKAI_VOL_TYPE_CD3000; /* force to CD3000 CD-ROM */
+					}else{
+						vtype=AKAI_VOL_TYPE_INACT; /* INACT: auto-detect */
+					}
+					/* flags */
+					if (cmdnr==CMD_TARXWAV){
+						flags=TAR_IMPORT_WAV;
+					}else if (cmdnr==CMD_TARXWAV9){
+						flags=TAR_IMPORT_WAV|TAR_IMPORT_WAVS9;
+					}else if (cmdnr==CMD_TARXWAV9C){
+						flags=TAR_IMPORT_WAV|TAR_IMPORT_WAVS9C;
+					}else if (cmdnr==CMD_TARXWAV1){
+						flags=TAR_IMPORT_WAV|TAR_IMPORT_WAVS1;
+					}else if (cmdnr==CMD_TARXWAV3){
+						flags=TAR_IMPORT_WAV|TAR_IMPORT_WAVS3;
+					}else{
+						flags=0;
+					}
+#if 1
+					if ((TAR_IMPORT_WAV&flags)!=0){
+						PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+						/* no current external WAV file */
+						curwavname[0]='\0';
+						curwavcmdbuf[0]='\0';
+					}
+#endif
+					/* import tar-file */
+					if (tar_import_curdir(inpfd,vtype,1,flags)<0){ /* 1: verbose */
+						PRINTF_ERR("tar error\n");
+					}
+					CLOSE(inpfd);
+				}
+				break;
+			case CMD_MKVOL:
+			case CMD_MKVOL9:
+			case CMD_MKVOL1:
+			case CMD_MKVOL3:
+			case CMD_MKVOL3CD:
+				{
+					struct vol_s tmpvol;
+					u_int lnum;
+					u_int vtype;
+
+					save_curdir(1); /* 1: could be modifications */
+					if (cmdtoknr>=2){
+						if (change_curdir(cmdtok[1],0,dirnamebuf,0)<0){
+							PRINTF_ERR("directory not found\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+						if ((strlen(dirnamebuf)==0)
+							||(strcmp(dirnamebuf,".")==0)||(strcmp(dirnamebuf,"..")==0)){
+								PRINTF_ERR("invalid volume name\n");
+								restore_curdir();
+								goto main_parser_next;
+						}
+					}
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("must be on sampler partition level\n");
+						restore_curdir();
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						restore_curdir();
+						goto main_parser_next;
+					}
+#if 1
+					if (cmdtoknr>=2){
+						/* check if new volume name already used */
+						if (akai_find_vol(curpartp,&tmpvol,dirnamebuf)==0){
+							PRINTF_ERR("volume name already used\n");
+							restore_curdir();
+							goto main_parser_next;
+						}
+					}
+#endif
+					/* load number */
+					if (cmdtoknr>=3){
+						lnum=akai_get_lnum(cmdtok[2]);
+					}else{
+						lnum=AKAI_VOL_LNUM_OFF;
+					}
+					/* volume type */
+					if (cmdnr==CMD_MKVOL){
+						/* derive volume type from partition type */
+						if (curpartp->type==PART_TYPE_HD9){
+							vtype=AKAI_VOL_TYPE_S900;
+						}else{
+							if (strncmp(AKAI_PARTHEAD_TAGSMAGIC,(char *)curpartp->head.hd.tagsmagic,4)!=0){
+								vtype=AKAI_VOL_TYPE_S3000;
+							}else{
+								/* default */
+								vtype=AKAI_VOL_TYPE_S1000;
+							}
+						}
+					}else if (cmdnr==CMD_MKVOL9){
+						vtype=AKAI_VOL_TYPE_S900;
+					}else if (cmdnr==CMD_MKVOL3){
+						vtype=AKAI_VOL_TYPE_S3000;
+					}else if (cmdnr==CMD_MKVOL3CD){
+						vtype=AKAI_VOL_TYPE_CD3000;
+					}else{
+						vtype=AKAI_VOL_TYPE_S1000;
+					}
+					/* create volume */
+					if (akai_create_vol(curpartp,&tmpvol,
+										vtype,
+										AKAI_CREATE_VOL_NOINDEX,
+										(cmdtoknr>=2)?dirnamebuf:NULL,
+										lnum,
+										NULL)<0){
+						PRINTF_ERR("cannot create volume\n");
+					}
+					restore_curdir();
+				}
+				break;
+			case CMD_MKVOLI9:
+			case CMD_MKVOLI1:
+			case CMD_MKVOLI3:
+			case CMD_MKVOLI3CD:
+				{
+					struct vol_s tmpvol;
+					u_int vi;
+					u_int lnum;
+					u_int vtype;
+
+					if ((cmdtoknr>=3)
+						&&((strcmp(cmdtok[2],".")==0)||(strcmp(cmdtok[2],"..")==0))){
+						PRINTF_ERR("invalid volume name\n");
+						goto main_parser_next;
+					}
+
+					if (check_curnosamplerpart()){ /* not on sampler partition level? */
+						PRINTF_ERR("must be on sampler partition level\n");
+						goto main_parser_next;
+					}
+					if (curdiskp->readonly){
+						PRINTF_ERR("disk%u: read-only, cannot write\n",curdiskp->index);
+						goto main_parser_next;
+					}
+					/* index */
+					vi=(u_int)atoi(cmdtok[1]);
+					if ((vi<1)||(vi>curpartp->volnummax)){
+						PRINTF_ERR("invalid volume index\n");
+						goto main_parser_next;
+					}
+					/* load number */
+					if (cmdtoknr>=4){
+						lnum=akai_get_lnum(cmdtok[3]);
+					}else{
+						lnum=AKAI_VOL_LNUM_OFF;
+					}
+					/* volume type */
+					if (cmdnr==CMD_MKVOLI){
+						/* derive volume type from partition type */
+						if (curpartp->type==PART_TYPE_HD9){
+							vtype=AKAI_VOL_TYPE_S900;
+						}else{
+							if (strncmp(AKAI_PARTHEAD_TAGSMAGIC,(char *)curpartp->head.hd.tagsmagic,4)!=0){
+								vtype=AKAI_VOL_TYPE_S3000;
+							}else{
+								/* default */
+								vtype=AKAI_VOL_TYPE_S1000;
+							}
+						}
+					}else if (cmdnr==CMD_MKVOLI9){
+						vtype=AKAI_VOL_TYPE_S900;
+					}else if (cmdnr==CMD_MKVOLI3){
+						vtype=AKAI_VOL_TYPE_S3000;
+					}else if (cmdnr==CMD_MKVOLI3CD){
+						vtype=AKAI_VOL_TYPE_CD3000;
+					}else{
+						vtype=AKAI_VOL_TYPE_S1000;
+					}
+					/* create volume */
+					if (akai_create_vol(curpartp,&tmpvol,
+										vtype,
+										vi-1,
+										(cmdtoknr>=3)?cmdtok[2]:NULL,
+										lnum,
+										NULL)<0){
+						PRINTF_ERR("cannot create volume\n");
+					}
+				}
+				break;
+			case CMD_DIRCACHE:
+				if (blk_cache_enable){ /* cache enabled? */
+					PRINTF_OUT("\n");
+					print_blk_cache();
+					PRINTF_OUT("\n");
+				}else{
+					PRINTF_OUT("cache is not enabled\n\n");
+				}
+				break;
+			case CMD_DISABLECACHE:
+				if (blk_cache_enable){ /* cache enabled? */
+					if (flush_blk_cache()<0){
+						/* XXX try once again */
+						PRINTF_ERR("trying again to flush cache\n");
+						FLUSH_ALL;
+						flush_blk_cache(); /* XXX if error, too late */
+					}
+					free_blk_cache();
+					blk_cache_enable=0; /* disable cache */
+				}
+				break;
+			case CMD_ENABLECACHE:
+				if (!blk_cache_enable){ /* cache disabled? */
+					init_blk_cache(); /* XXX actually not necessary here (after init_blk_cache() or free_blk_cache()) */
+					blk_cache_enable=1; /* enable cache */
+				}
+				break;
+			case CMD_LOCK:
+#ifdef _VISUALCPP
+				if (lockh!=INVALID_HANDLE_VALUE){
+					if (!lockflag){
+						/* acquire lock */
+						if (LockFileEx(lockh,LOCKFILE_EXCLUSIVE_LOCK,0,1,0,&lockov)==FALSE){ /* XXX 1 byte */
+							PRINTF_ERR("cannot acquire lock\n");
+						}else{
+							lockflag=1;
+						}
+					}else{
+						PRINTF_ERR("lock already acquired\n");
+					}
+#else /* !_VISUALCPP */
+				if (lockfd>=0){
+					if (!lockflag){
+						/* acquire lock */
+						lockfl.l_type=F_WRLCK; /* exclusive lock */
+						if (fcntl(lockfd,F_SETLKW,&lockfl)<0){
+							PRINTF_ERR("cannot acquire lock\n");
+						}else{
+							lockflag=1;
+						}
+					}else{
+						PRINTF_ERR("lock already acquired\n");
+					}
+#endif /* !_VISUALCPP */
+				}else{
+					PRINTF_ERR("no lock-file\n");
+				}
+				break;
+			case CMD_UNLOCK:
+#ifdef _VISUALCPP
+				if (lockh!=INVALID_HANDLE_VALUE){
+					if (lockflag){
+						/* release lock */
+						if (UnlockFileEx(lockh,0,1,0,&lockov)==FALSE){ /* XXX 1 byte */
+							PRINTF_ERR("cannot release lock\n");
+						}else{
+							lockflag=0;
+						}
+					}else{
+						PRINTF_ERR("lock currently not acquired\n");
+					}
+#else /* !_VISUALCPP */
+				if (lockfd>=0){
+					if (lockflag){
+						/* release lock */
+						lockfl.l_type=F_UNLCK;
+						if (fcntl(lockfd,F_SETLKW,&lockfl)<0){
+							PRINTF_ERR("cannot release lock\n");
+						}else{
+							lockflag=0;
+						}
+					}else{
+						PRINTF_ERR("lock currently not acquired\n");
+					}
+#endif /* !_VISUALCPP */
+				}else{
+					PRINTF_ERR("no lock-file\n");
+				}
+				break;
+			case CMD_PLAYWAV:
+				PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+				if (cmdtoknr>=2){
+					/* given WAV file name */
+					/* check external WAV file name (and modify given file name if required) */
+					/* Note: string in cmdtok[1] may be modified here */
+					if (akai_check_extwavname(cmdtok[1])<0){
+						/* no current external WAV file */
+						curwavname[0]='\0';
+						curwavcmdbuf[0]='\0';
+						goto main_parser_next;
+					}
+					SNPRINTF(curwavname,CURWAVNAMEMAXLEN,"%s",cmdtok[1]);
+					PLAYWAV_PREPARE(curwavcmdbuf,CURWAVCMDBUFSIZ,curwavname);
+				}
+				if (curwavcmdbuf[0]!='\0'){
+					/* start playback of current external WAV file */
+					PLAYWAV_START(curwavcmdbuf); /* XXX no error check */
+				}else{
+					PRINTF_OUT("no current WAV file\n");
+				}
+				break;
+			case CMD_STOPWAV:
+				PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+				break;
+			case CMD_DELWAV:
+				PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+				if (curwavname[0]!='\0'){
+					/* check external WAV file name (and modify given file name if required) */
+					/* Note: string in curwavname may be modified here */
+					if (akai_check_extwavname(curwavname)==0){
+						/* delete current external WAV file */
+						LDELFILE(curwavcmdbuf,CURWAVCMDBUFSIZ,curwavname); /* XXX no error check */
+					}
+					/* no current external WAV file */
+					curwavname[0]='\0';
+					curwavcmdbuf[0]='\0';
+				}else{
+					PRINTF_OUT("no current WAV file\n");
+				}
+				break;
+			default:
+				PRINTF_OUT("unknown command, try \"help\"\n\n");
+				break;
+			}
+main_parser_next:
+#if 1 /* XXX flush cache every now and then */
+			if (blk_cache_enable){ /* cache enabled? */
+				flush_blk_cache(); /* XXX if error, maybe next time more luck */
+			}
+#endif
+			PRINTF_OUT("\n");
+#ifdef DEBUG
+			if (blk_cache_enable){ /* cache enabled? */
+				print_blk_cache();
+			}
+#endif
+			FLUSH_ALL;
+		} /* main command loop */
+	} /* command interpreter */
+
+main_exit:
+
+	FLUSH_ALL;
+
+	PLAYWAV_STOP; /* stop playback of current external WAV file (if currently running) */
+
+	if (blk_cache_enable){ /* cache enabled? */
+		if (flush_blk_cache()<0){
+			/* XXX try once again */
+			PRINTF_ERR("trying again to flush cache\n");
+			FLUSH_ALL;
+			flush_blk_cache(); /* XXX if error, too late */
+		}
+		free_blk_cache();
+	}
+
+	/* close all disk-files/drives */
+	close_alldisks();
+
+#ifdef _VISUALCPP
+	fldr_end();
+	if (lockh!=INVALID_HANDLE_VALUE){
+		if (lockflag){
+			/* release lock */
+			UnlockFileEx(lockh,0,1,0,&lockov); /* XXX 1 byte, XXX ignore error */
+			lockflag=0;
+		}
+		/* close lock-file */
+		CloseHandle(lockh);
+		lockh=INVALID_HANDLE_VALUE;
+	}
+#else /* !_VISUALCPP */
+	if (lockfd>=0){
+		if (lockflag){
+			/* release lock */
+			lockfl.l_type=F_UNLCK;
+			fcntl(lockfd,F_SETLKW,&lockfl); /* XXX ignore error */
+			lockflag=0;
+		}
+		/* close lock-file */
+		CLOSE(lockfd);
+		lockfd=-1;
+	}
+#endif /* !_VISUALCPP */
+
+	AKAIUTIL_EXIT(mainret);
+}
+
+
+
+/* EOF */
diff --git a/third_party/akaiutil/akaiutil_take.c b/third_party/akaiutil/akaiutil_take.c
new file mode 100755
index 0000000..cd62f24
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_take.c
@@ -0,0 +1,1040 @@
+/*
+* Copyright (C) 2012,2018,2019,2020,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+#include "akaiutil_io.h"
+#include "akaiutil.h"
+#include "akaiutil_take.h"
+#include "akaiutil_wav.h"
+
+
+
+int
+akai_ddtake_info(struct part_s *pp,u_int ti,int verbose)
+{
+	char namebuf[DIRNAMEBUF_LEN+1]; /* +1 for '\0' */
+	struct akai_ddtake_s *tp;
+	u_int cstarts,cstarte;
+	u_int csizes,csizee;
+	u_int scount;
+	u_int srate;
+	double vspeed;
+
+	if ((pp==NULL)||(!pp->valid)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+
+	if (ti>=AKAI_DDTAKE_MAXNUM){
+		if (verbose){
+			PRINTF_ERR("invalid take index\n");
+		}
+		return -1;
+	}
+
+	tp=&pp->head.dd.take[ti];
+
+	if (tp->stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+		if (verbose){
+			PRINTF_ERR("take not found\n");
+		}
+		return -1;
+	}
+
+	/* clusters */
+	cstarts=(tp->cstarts[1]<<8)
+		    +tp->cstarts[0];
+	cstarte=(tp->cstarte[1]<<8)
+		    +tp->cstarte[0];
+
+	/* determine csizes (sample clusters) and csizee (envelope clusters) */
+	if (cstarts!=0){ /* sample not empty? */
+		csizes=akai_count_ddfatchain(pp,cstarts);
+	}else{
+		csizes=0;
+	}
+	if (cstarte!=0){ /* envelope not empty? */
+		csizee=akai_count_ddfatchain(pp,cstarte);
+	}else{
+		csizee=0;
+	}
+
+	/* used sample count */
+	scount=(tp->wend[3]<<24)
+		+(tp->wend[2]<<16)
+		+(tp->wend[1]<<8)
+		+tp->wend[0]
+		-(tp->wstart[3]<<24)
+		-(tp->wstart[2]<<16)
+		-(tp->wstart[1]<<8)
+		-tp->wstart[0];
+	/* XXX no check if scount is compatible with csizes */
+
+	/* samplerate */
+	srate=(tp->srate[1]<<8)
+		  +tp->srate[0];
+
+	/* name */
+	akai2ascii_name(tp->name,namebuf,0); /* 0: not S900 */
+
+	if (verbose){
+		PRINTF_OUT("%s%s\n",namebuf,AKAI_DDTAKE_FNAMEEND);
+		PRINTF_OUT("tnr:      %u\n",ti+1);
+		PRINTF_OUT("tname:    \"%s\"\n",namebuf);
+		PRINTF_OUT("cstarts:  cluster 0x%04x\n",cstarts);
+		PRINTF_OUT("cstarte:  cluster 0x%04x\n",cstarte);
+		PRINTF_OUT("csizes:   0x%04x clusters (%9u bytes)\n",
+			csizes,
+			csizes*AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE);
+		PRINTF_OUT("csizee:   0x%04x clusters (%9u bytes)\n",
+			csizee,
+			csizee*AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE);
+		PRINTF_OUT("scount:   0x%08x (%9u)\n",scount,scount);
+		PRINTF_OUT("stype:    %s\n",(tp->stype==AKAI_DDTAKESTYPE_MONO)?"MONO":"STEREO");
+		PRINTF_OUT("srate:    %uHz\n",srate);
+		vspeed=((double)((((int)(char)tp->vspeed[1])<<8)+((int)(u_char)tp->vspeed[0])))/256.0; /* in % */
+		PRINTF_OUT("vspeed:   %+06.2lf%%\n",vspeed);
+		PRINTF_OUT("finerate: %+05ippm\n",(((int)(char)tp->finerate[1])<<8)+((int)(u_char)tp->finerate[0]));
+		PRINTF_OUT("wstart:   0x%02x%02x%02x%02x\n",tp->wstart[3],tp->wstart[2],tp->wstart[1],tp->wstart[0]);
+		PRINTF_OUT("wend:     0x%02x%02x%02x%02x\n",tp->wend[3],tp->wend[2],tp->wend[1],tp->wend[0]);
+		PRINTF_OUT("wstartm:  0x%02x%02x%02x%02x\n",tp->wstartm[3],tp->wstartm[2],tp->wstartm[1],tp->wstartm[0]);
+		PRINTF_OUT("wendm:    0x%02x%02x%02x%02x\n",tp->wendm[3],tp->wendm[2],tp->wendm[1],tp->wendm[0]);
+		PRINTF_OUT("fadein:   %ums\n",(tp->fadein[1]<<8)+tp->fadein[0]);
+		PRINTF_OUT("fadeout:  %ums\n",(tp->fadeout[1]<<8)+tp->fadeout[0]);
+		PRINTF_OUT("stlvl:    %u\n",tp->stlvl);
+		PRINTF_OUT("pan:      %+i\n",(int)(char)tp->pan);
+		PRINTF_OUT("stmix:    %s\n",tp->stmix?"ON":"OFF");
+		PRINTF_OUT("midich:   %u\n",tp->midich1+1);
+		PRINTF_OUT("midinote: %u\n",tp->midinote);
+		PRINTF_OUT("startm:   ");
+		switch (tp->startm){
+		case 0x00:
+			PRINTF_OUT("IMMEDIATE\n");
+			break;
+		case 0x01:
+			PRINTF_OUT("MIDI FOOTSW\n");
+			break;
+		case 0x02:
+			PRINTF_OUT("MIDI NOTE\n");
+			break;
+		case 0x03:
+			PRINTF_OUT("M.NOTE+DEL\n");
+			break;
+		case 0x04:
+			PRINTF_OUT("START SONG\n");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?\n");
+			break;
+		}
+		PRINTF_OUT("deemph:   %s\n",tp->deemph?"ON":"OFF");
+		PRINTF_OUT("predel:   %u\n",(tp->predel[1]<<8)+tp->predel[0]);
+		PRINTF_OUT("outlvl:   %u\n",tp->outlvl);
+		PRINTF_OUT("outch:    ");
+		switch (tp->outch){
+		case 0x00:
+			PRINTF_OUT("OFF\n");
+			break;
+		case 0x01:
+			PRINTF_OUT("1/2\n");
+			break;
+		case 0x02:
+			PRINTF_OUT("3/4\n");
+			break;
+		case 0x03:
+			PRINTF_OUT("5/6\n");
+			break;
+		case 0x04:
+			PRINTF_OUT("7/8\n");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?\n");
+			break;
+		}
+		PRINTF_OUT("fxbus:    ");
+		switch (tp->fxbus){
+		case 0x00:
+			PRINTF_OUT("OFF\n");
+			break;
+		case 0x01:
+			PRINTF_OUT("FX1\n");
+			break;
+		case 0x02:
+			PRINTF_OUT("FX2\n");
+			break;
+		case 0x03:
+			PRINTF_OUT("RV3\n");
+			break;
+		case 0x04:
+			PRINTF_OUT("RV4\n");
+			break;
+		default:
+			PRINTF_OUT("\?\?\?\n");
+			break;
+		}
+		PRINTF_OUT("sendlvl:  %u\n",tp->sendlvl);
+	}else{
+		PRINTF_OUT("%3u  %-12s  0x%04x  0x%04x  0x%04x  0x%04x  %9u  %5u  %s\n",
+			ti+1,namebuf,
+			cstarts,cstarte,
+			csizes,csizee,
+			scount,
+			srate,
+			(tp->stype==AKAI_DDTAKESTYPE_MONO)?"MONO  ":"STEREO");
+	}
+
+	return 0;
+}
+
+
+
+int
+akai_import_take(int inpfd,struct part_s *pp,struct akai_ddtake_s *tp,u_int ti,u_int csizes,u_int csizee)
+{
+	u_int cstarts,cstarte;
+	u_int samplesize;
+	u_int envsiz;
+	u_char *envbuf;
+	u_int bsize;
+	int ret;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+
+	if (tp==NULL){
+		return -1;
+	}
+
+	if (ti>=AKAI_DDTAKE_MAXNUM){
+		return -1;
+	}
+
+	/* Note: don't check if name already used, create new DD take */
+
+	ret=-1; /* no success so far */
+	envsiz=0;
+	envbuf=NULL; /* not allocated yet */
+
+	/* total number of bytes for sample */
+	samplesize=csizes*AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE;
+
+	if ((csizee==0) /* no envelope in file? */
+		&&(samplesize>0)){ /* and sample not empty? */
+		/* new envelope */
+		envsiz=((samplesize/2)+AKAI_DDTAKE_ENVBLKSIZW-1)/AKAI_DDTAKE_ENVBLKSIZW; /* number of bytes for envelope, round up (Note: /2 for 16bit per sample word) */
+		csizee=(envsiz+AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE-1)/(AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE); /* in clusters, round up */
+		/* allocate envelope buffer */
+		if ((envbuf=(u_char *)malloc(envsiz))==NULL){
+			PRINTF_ERR("cannot allocate envelope buffer\n");
+			goto akai_import_take_exit;
+		}
+	}
+
+	if ((csizes+csizee)*AKAI_DDPART_CBLKS>pp->bfree){
+		PRINTF_ERR("not enough space left\n");
+		goto akai_import_take_exit;
+	}
+	/* allocate space for take */
+	if (csizes>0){
+		/* sample */
+#if 1
+		if (akai_allocate_ddfatchain(pp,csizes,&cstarts,1)<0){ /* 1: not necessarily contiguous */
+#else
+		if (akai_allocate_ddfatchain(pp,csizes,&cstarts,csizes)<0){ /* contiguous */
+#endif
+			PRINTF_ERR("cannot allocate FAT chain for sample\n");
+			goto akai_import_take_exit;
+		}
+	}else{
+		cstarts=0; /* empty sample */
+	}
+	if (csizee>0){
+		/* envelope */
+#if 1
+		if (akai_allocate_ddfatchain(pp,csizee,&cstarte,1)<0){ /* 1: not necessarily contiguous */
+#else
+		if (akai_allocate_ddfatchain(pp,csizee,&cstarte,csizee)<0){ /* contiguous */
+#endif
+			PRINTF_ERR("cannot allocate FAT chain for envelope\n");
+			if (csizes>0){
+				/* free FAT at cstarts */
+				akai_free_ddfatchain(pp,cstarts,1); /* XXX ignore error */
+				goto akai_import_take_exit;
+			}
+		}
+	}else{
+		cstarte=0; /* empty envelope */
+	}
+
+	/* fundamental settings of DD take */
+	tp->stat=AKAI_DDTAKESTAT_USED; /* used */
+	/* set cstarts and cstarte in DD take header */
+	tp->cstarts[1]=0xff&(cstarts>>8);
+	tp->cstarts[0]=0xff&cstarts;
+	tp->cstarte[1]=0xff&(cstarte>>8);
+	tp->cstarte[0]=0xff&cstarte;
+	/* XXX keep name */
+	/* copy DD take header into directory entry */
+	bcopy(tp,&pp->head.dd.take[ti],sizeof(struct akai_ddtake_s));
+	/* write partition header */
+	if (akai_io_blks(pp,(u_char *)&pp->head.dd,
+					 0,
+					 AKAI_DDPARTHEAD_BLKS,
+					 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+		PRINTF_ERR("cannot write partition header\n");
+		goto akai_import_take_exit;
+	}
+
+	if (csizes>0){
+		/* sample */
+		if (akai_import_ddfatchain(pp,cstarts,0,samplesize,inpfd,NULL)<0){
+			PRINTF_ERR("cannot import DD take\n");
+			goto akai_import_take_exit;
+		}
+	}
+
+	if (csizee>0){
+		/* envelope */
+		if (envbuf!=NULL){ /* no envelope in file? (see above) */
+			/* calculate envelope from sample */
+			if (akai_take_setenv(pp,cstarts,samplesize,envbuf,envsiz)<0){
+				goto akai_import_take_exit;
+			}
+			/* write envelope to DD take */
+			if (akai_import_ddfatchain(pp,cstarte,0,envsiz,-1,envbuf)<0){
+				PRINTF_ERR("cannot save envelope\n");
+				goto akai_import_take_exit;
+			}
+		}else{
+			/* import envelope from file */
+			bsize=csizee*AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE;
+			if (akai_import_ddfatchain(pp,cstarte,0,bsize,inpfd,NULL)<0){
+				PRINTF_ERR("cannot import DD take\n");
+				goto akai_import_take_exit;
+			}
+		}
+	}
+
+	ret=0; /* success */
+
+akai_import_take_exit:
+	if (envbuf!=NULL){
+		free(envbuf);
+	}
+	return ret;
+}
+
+
+
+int
+akai_export_take(int outfd,struct part_s *pp,struct akai_ddtake_s *tp,u_int csizes,u_int csizee,u_int cstarts,u_int cstarte)
+{
+	u_int bsize;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+
+	if (tp!=NULL){
+		/* export DD take header */
+		if (WRITE(outfd,tp,sizeof(struct akai_ddtake_s))!=(int)sizeof(struct akai_ddtake_s)){
+			PRINTF_ERR("cannot export DD take header\n");
+			return -1;
+		}
+	}
+
+	if (csizes>0){
+		/* sample */
+		bsize=csizes*AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE; /* in bytes */
+		if (akai_export_ddfatchain(pp,cstarts,0,bsize,outfd,NULL)<0){
+			PRINTF_ERR("cannot export DD take sample\n");
+			return -1;
+		}
+	}
+
+	if (csizee>0){
+		/* envelope */
+		bsize=csizee*AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE; /* in bytes */
+		if (akai_export_ddfatchain(pp,cstarte,0,bsize,outfd,NULL)<0){
+			PRINTF_ERR("cannot export DD take envelope\n");
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+
+
+int
+akai_take2wav(struct part_s *pp,u_int ti,int wavfd,u_int *sizep,char **wavnamep,int what)
+{
+	/* Note: static for multiple calls with different what */
+	static u_int cstarts;
+	static u_int samplestart;
+	static u_int samplesize;
+	static u_int samplerate;
+	static u_int samplechnr;
+	static int ret;
+	static char wavname[AKAI_NAME_LEN+4+1]; /* name (ASCII), +4 for ".<type>", +1 for '\0' */
+	static u_int nlen;
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+
+	if (ti>=AKAI_DDTAKE_MAXNUM){
+		return -1;
+	}
+
+	ret=-1; /* no success so far */
+
+	if (what&TAKE2WAV_CHECK){
+
+		if (pp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+			return -1;
+		}
+
+		/* sample start cluster */
+		cstarts=(pp->head.dd.take[ti].cstarts[1]<<8)
+			    +pp->head.dd.take[ti].cstarts[0];
+		if (cstarts!=0){ /* sample not empty? */
+#if 1
+			/* Note: words are 16bit */
+			/* start word */
+			samplestart=(pp->head.dd.take[ti].wstart[3]<<24)
+				+(pp->head.dd.take[ti].wstart[2]<<16)
+				+(pp->head.dd.take[ti].wstart[1]<<8)
+				+pp->head.dd.take[ti].wstart[0];
+			/* end word */
+			samplesize=(pp->head.dd.take[ti].wend[3]<<24)
+				+(pp->head.dd.take[ti].wend[2]<<16)
+				+(pp->head.dd.take[ti].wend[1]<<8)
+				+pp->head.dd.take[ti].wend[0];
+			if (samplesize<samplestart){ /* end<start? */
+				return -1;
+			}
+			samplesize-=samplestart; /* size in words */
+			samplestart*=2; /* *2 for 16bit per sample word */
+			samplesize*=2; /* *2 for 16bit per sample word */
+			/* XXX check samplestart and samplesize */
+#else
+			/* all clusters */
+			samplestart=0;
+			samplesize=akai_count_ddfatchain(pp,cstarts)*AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE; /* in bytes */
+#endif
+		}else{
+			samplestart=0;
+			samplesize=0;
+		}
+		/* Note: samplesize==0 is allowed here */
+
+		/* take parameters */
+		samplerate=(pp->head.dd.take[ti].srate[1]<<8)
+			+pp->head.dd.take[ti].srate[0];
+		samplechnr=(pp->head.dd.take[ti].stype==AKAI_DDTAKESTYPE_MONO)?1:2;
+
+#ifdef DEBUG
+		PRINTF_OUT("samplestart: %15u bytes\n",samplestart);
+		PRINTF_OUT("samplesize:  %15u bytes\n",samplesize);
+		PRINTF_OUT("samplerate:  %15u Hz\n",samplerate);
+		PRINTF_OUT("samplechnr:  %15u\n",samplechnr);
+#endif
+
+		if (sizep!=NULL){
+			/* WAV file size */
+			*sizep=WAV_HEAD_SIZE+samplesize;
+#ifndef WAV_AKAIHEAD_DISABLE
+			*sizep+=sizeof(struct wav_chunkhead_s)+sizeof(struct akai_ddtake_s); /* DD take header chunk (see below) */
+#endif
+		}
+
+		/* create WAV name */
+		akai2ascii_name(pp->head.dd.take[ti].name,wavname,0); /* 0: not S900 */
+		nlen=(u_int)strlen(wavname);
+		bcopy(".wav",wavname+nlen,5);
+
+		if (wavnamep!=NULL){
+			/* pointer to name (wavname must be static!) */
+			*wavnamep=wavname;
+		}
+	}
+
+	if (what&TAKE2WAV_EXPORT){
+
+		if (what&TAKE2WAV_CREATE){
+			/* create WAV file */
+			if ((wavfd=OPEN(wavname,O_RDWR|O_CREAT|O_TRUNC|O_BINARY,0666))<0){
+				PERROR("create WAV");
+				goto akai_take2wav_exit;
+			}
+		}
+
+		/* write WAV header */
+		if (wav_write_head(wavfd,
+						   samplesize,samplechnr,samplerate,16, /* 16: 16bit */
+#ifndef WAV_AKAIHEAD_DISABLE
+						   sizeof(struct wav_chunkhead_s)+sizeof(struct akai_ddtake_s) /* DD take header chunk (see below) */
+#else
+						   0
+#endif
+						   )<0){
+			PRINTF_ERR("cannot write WAV header\n");
+			goto akai_take2wav_exit;
+		}
+
+		if (samplesize>0){
+			/* Note: no sample format conversion necessary */
+			/* export sample */
+			if (akai_export_ddfatchain(pp,cstarts,samplestart,samplesize,wavfd,NULL)<0){
+				PERROR("write WAV samples");
+				goto akai_take2wav_exit;
+			}
+		}
+
+#ifndef WAV_AKAIHEAD_DISABLE
+		{
+			struct wav_chunkhead_s wavchunkhead;
+			struct akai_ddtake_s t;
+			u_int hdrsize;
+			u_int csizes;
+
+			/* create DD take header chunk */
+			bcopy(WAV_CHUNKHEAD_AKAIDDTAKEHEADSTR,wavchunkhead.typestr,4);
+			hdrsize=sizeof(struct akai_ddtake_s);
+			wavchunkhead.csize[0]=0xff&hdrsize;
+			wavchunkhead.csize[1]=0xff&(hdrsize>>8);
+			wavchunkhead.csize[2]=0xff&(hdrsize>>16);
+			wavchunkhead.csize[3]=0xff&(hdrsize>>24);
+			/* write WAV chunk header */
+			if (WRITE(wavfd,(u_char *)&wavchunkhead,sizeof(struct wav_chunkhead_s))!=(int)sizeof(struct wav_chunkhead_s)){
+				PERROR("write WAV chunk");
+				goto akai_take2wav_exit;
+			}
+			/* get DD take header from directory entry */
+			bcopy((u_char *)&pp->head.dd.take[ti],&t,hdrsize);
+			/* determine csizes (sample clusters) and csizee (envelope clusters) */
+			csizes=akai_count_ddfatchain(pp,cstarts);
+			/* Note: no envelope in WAV file -> csizee=0 */
+			/* XXX use cstarts/cstarte fields in DD take header for csizes/csizee */
+			t.cstarts[1]=0xff&(csizes>>8);
+			t.cstarts[0]=0xff&csizes;
+			t.cstarte[1]=0x00;
+			t.cstarte[0]=0x00;
+			/* write DD take header */
+			if (WRITE(wavfd,(u_char *)&t,hdrsize)!=(int)hdrsize){
+				PERROR("write WAV chunk");
+				goto akai_take2wav_exit;
+			}
+		}
+#endif
+#if 1
+		PRINTF_OUT("DD take exported to WAV\n");
+#endif
+	}
+
+	ret=0; /* success */
+
+akai_take2wav_exit:
+	if (what&TAKE2WAV_CREATE){
+		if (wavfd>=0){
+			CLOSE(wavfd);
+		}
+	}
+	return ret;
+}
+
+
+
+int
+akai_wav2take(int wavfd,char *wavname,struct part_s *pp,u_int ti,u_int *bcountp,int what)
+{
+	/* Note: static for multiple calls with different what */
+	static struct akai_ddtake_s t;
+	static u_int samplerate;
+	static u_int samplesize;
+	static u_int wavchnr;
+	static u_int wavbitnr;
+	static u_int wavsamplesize;
+	static u_int wavsamplesizealloc;
+	static u_int wavsamplecount;
+	static u_char *wavbuf;
+	static char *errstrp;
+	static u_int nlen;
+	static char name[AKAI_NAME_LEN+1]; /* name (ASCII), +1 for '\0' */
+	static u_int cstarts,cstarte;
+	static u_int csizes,csizee;
+	static u_int envsiz;
+	static u_char *envbuf;
+	static u_int bcount;
+#ifndef WAV_AKAIHEAD_DISABLE
+	static u_int extrasize;
+	static int wavakaiheadfound;
+#endif
+	static u_int i,j;
+	static int ret;
+
+	if (bcountp!=NULL){
+		*bcountp=0; /* no bytes read yet */
+	}
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+
+	if (ti>=AKAI_DDTAKE_MAXNUM){
+		return -1;
+	}
+
+	/* check WAV name */
+	if (wavname==NULL){
+		return -1;
+	}
+	nlen=(u_int)strlen(wavname);
+	if ((nlen<4)||(strncasecmp(wavname+nlen-4,".wav",4)!=0)){
+		/* not a WAV file */
+		return 1; /* no error */
+	}
+	nlen-=4; /* remove suffix */
+
+	/* Note: don't check if name already used, create new DD take */
+
+	ret=-1; /* no success so far */
+	bcount=0; /* no bytes read yet */
+	envbuf=NULL; /* not allocated yet */
+	wavbuf=NULL; /* not allocated yet */
+
+	if (what&WAV2TAKE_OPEN){
+		/* open external WAV file */
+		if ((wavfd=akai_openreadonly_extfile(wavname))<0){
+			PERROR("open WAV");
+			goto akai_wav2take_exit;
+		}
+	}
+
+	/* read and parse WAV header */
+	if (wav_read_head(wavfd,&bcount,
+					  &wavsamplesize,&wavchnr,&samplerate,&wavbitnr,
+#ifndef WAV_AKAIHEAD_DISABLE
+					  &extrasize,
+#else
+					  NULL,
+#endif
+					  &errstrp)<0){
+		if (errstrp!=NULL){
+			PRINTF_ERR("%s\n",errstrp);
+		}
+		/* error, don't know how many bytes read */
+		goto akai_wav2take_exit;
+	}
+
+	/* check parameters */
+	if ((wavchnr!=1)&&(wavchnr!=2)){
+		PRINTF_ERR("invalid number of channels, must be mono or stereo\n");
+		/* unknown or unsupported */
+		ret=1; /* no error */
+		goto akai_wav2take_exit;
+	}
+	if ((wavbitnr!=8)&&(wavbitnr!=16)&&(wavbitnr!=24)&&(wavbitnr!=32)){
+		PRINTF_ERR("invalid WAV format, must be 8bit or 16bit or 24bit or 32bit PCM\n");
+		/* unknown or unsupported */
+		ret=1; /* no error */
+		goto akai_wav2take_exit;
+	}
+
+	/* number of samples in WAV file */
+	/* Note: sum over all channels */
+	wavsamplecount=wavsamplesize/(wavbitnr/8);
+#if 0
+	if (wavsamplecount==0){
+		PRINTF_ERR("no samples in WAV file\n");
+		ret=1; /* no error */
+		goto akai_wav2take_exit;
+	}
+#endif /* else: Note: wavesamplecount==0 is allowed here */
+
+	if (wavsamplecount>0){
+		/* determine csizes (sample clusters) and csizee (envelope clusters) */
+		samplesize=wavsamplecount*2; /* 16bit per sample word in DD take */
+		csizes=(samplesize+AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE-1)/(AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE); /* in clusters, round up */
+		envsiz=((samplesize/2)+AKAI_DDTAKE_ENVBLKSIZW-1)/AKAI_DDTAKE_ENVBLKSIZW; /* number of bytes for envelope, round up (Note: /2 for 16bit per sample word) */
+		csizee=(envsiz+AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE-1)/(AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE); /* in clusters, round up */
+
+		/* allocate envelope buffer */
+		if ((envbuf=(u_char *)malloc(envsiz))==NULL){
+			PRINTF_ERR("cannot allocate envelope buffer\n");
+			goto akai_wav2take_exit;
+		}
+
+		/* allocate space for take */
+#if 1
+		if (akai_allocate_ddfatchain(pp,csizes,&cstarts,1)<0){ /* 1: not necessarily contiguous */
+#else
+		if (akai_allocate_ddfatchain(pp,csizes,&cstarts,csizes)<0){ /* contiguous */
+#endif
+			PRINTF_ERR("cannot allocate FAT chain for sample\n");
+			goto akai_wav2take_exit;
+		}
+#if 1
+		if (akai_allocate_ddfatchain(pp,csizee,&cstarte,1)<0){ /* 1: not necessarily contiguous */
+#else
+		if (akai_allocate_ddfatchain(pp,csizee,&cstarte,csizee)<0){ /* contiguous */
+#endif
+			PRINTF_ERR("cannot allocate FAT chain for envelope\n");
+			/* free FAT at cstarts */
+			akai_free_ddfatchain(pp,cstarts,1); /* XXX ignore error */
+			goto akai_wav2take_exit;
+		}
+	}else{
+		samplesize=0;
+		csizes=0;
+		envsiz=0;
+		csizee=0;
+		cstarts=0; /* no sample */
+		cstarte=0; /* no envelope */
+	}
+
+	if (csizes>0){
+		/* read WAV sample and write sample to DD take */
+#if 1
+		if (wavbitnr==16){
+			/* Note: no sample format conversion necessary */
+			/* copy sample from WAV file to DD take */
+			if (akai_import_ddfatchain(pp,cstarts,0,samplesize,wavfd,NULL)<0){
+				PRINTF_ERR("cannot import DD take\n");
+				goto akai_wav2take_exit;
+			}
+			bcount+=samplesize;
+		}else
+#endif
+		{
+			/* allocate WAV sample buffer */
+			/* buffer for at least 16bit */
+			if (wavbitnr>16){
+				wavsamplesizealloc=wavsamplecount*(wavbitnr/8);
+			}else{
+				wavsamplesizealloc=wavsamplecount*(16/8);
+			}
+			wavbuf=(u_char *)malloc(wavsamplesizealloc);
+			if (wavbuf==NULL){
+				PRINTF_ERR("cannot allocate WAV buffer\n");
+				goto akai_wav2take_exit;
+			}
+
+			/* read WAV sample to memory */
+			if (READ(wavfd,wavbuf,wavsamplesize)!=(int)wavsamplesize){
+				PRINTF_ERR("cannot read sample\n");
+				goto akai_wav2take_exit;
+			}
+			bcount+=wavsamplesize;
+			if (wavbitnr==8){
+				/* convert 8bit WAV sample format into 16bit WAV sample format */
+				/* Note: write pointer must not overtake read pointer => address sequence must be downwards */
+				for (i=0;i<wavsamplecount;i++){
+					j=wavsamplecount-1-i;
+					wavbuf[j*2+1]=0x80^wavbuf[j]; /* toggle sign bit */
+					wavbuf[j*2+0]=0x00;
+				}
+			}else if (wavbitnr==24){
+				/* convert 24bit WAV sample format into 16bit WAV sample format */
+				/* Note: write pointer must not overtake read pointer => address sequence must be upwards */
+				for (i=0;i<wavsamplecount;i++){
+					/* Note: copy upper 16 bits, discard lower 8 bits */
+					wavbuf[i*2+0]=wavbuf[i*3+1];
+					wavbuf[i*2+1]=wavbuf[i*3+2];
+				}
+			}else if (wavbitnr==32){
+				/* convert 32bit WAV sample format into 16bit WAV sample format */
+				/* Note: write pointer must not overtake read pointer => address sequence must be upwards */
+				for (i=0;i<wavsamplecount;i++){
+					/* Note: copy upper 16 bits, discard lower 16 bits */
+					wavbuf[i*2+0]=wavbuf[i*4+2];
+					wavbuf[i*2+1]=wavbuf[i*4+3];
+				}
+			}
+
+			/* write sample to DD take */
+			if (akai_import_ddfatchain(pp,cstarts,0,samplesize,-1,wavbuf)<0){
+				PRINTF_ERR("cannot import DD take\n");
+				goto akai_wav2take_exit;
+			}
+		}
+	}
+
+	if (csizee>0){
+		/* Note: no envelope in WAV file */
+		/* calculate envelope from sample */
+		if (akai_take_setenv(pp,cstarts,samplesize,envbuf,envsiz)<0){
+			goto akai_wav2take_exit;
+		}
+		/* write envelope to DD take */
+		if (akai_import_ddfatchain(pp,cstarte,0,envsiz,-1,envbuf)<0){
+			PRINTF_ERR("cannot save envelope\n");
+			goto akai_wav2take_exit;
+		}
+	}
+
+#ifndef WAV_AKAIHEAD_DISABLE
+	/* check for DD take header chunk in WAV file */
+	{
+		int wavakaiheadtype;
+		u_int wavakaiheadsize;
+		u_int bc;
+
+		wavakaiheadtype=wav_find_akaihead(wavfd,&bc,&wavakaiheadsize,extrasize,WAV_AKAIHEADTYPE_DDTAKE);
+		if (wavakaiheadtype<0){
+			goto akai_wav2take_exit;
+		}
+		bcount+=bc;
+
+		if ((wavakaiheadtype==(int)WAV_AKAIHEADTYPE_DDTAKE)&&(wavakaiheadsize==sizeof(struct akai_ddtake_s))){
+			/* found matching DD take header chunk */
+			wavakaiheadfound=1;
+		}else{
+			wavakaiheadfound=0;
+		}
+	}
+
+	if (wavakaiheadfound){
+		/* read DD take header */
+		if (READ(wavfd,(u_char *)&t,sizeof(struct akai_ddtake_s))!=(int)sizeof(struct akai_ddtake_s)){
+			PRINTF_ERR("cannot read DD take header\n");
+			goto akai_wav2take_exit;
+		}
+		bcount+=sizeof(struct akai_ddtake_s);
+#if 1
+		PRINTF_OUT("DD take header imported from WAV\n");
+#endif
+		/* Note: ignore cstarts/cstarte fields in DD take header */
+		/* Note: keep name in DD take header */
+		/* Note: must overwrite some settings in DD take header (see below) */
+	}else
+#endif
+	{
+		u_int wstart,wend;
+		u_int wstartm,wendm;
+
+		/* create DD take header */
+		bzero((void *)&t,sizeof(struct akai_ddtake_s));
+		/* default parameter settings */
+		wstart=0;
+		wend=samplesize/2; /* /2 for 16bit per sample word */
+		wstartm=wstart;
+		wendm=wend;
+		t.wstart[3]=0xff&(wstart>>24);
+		t.wstart[2]=0xff&(wstart>>16);
+		t.wstart[1]=0xff&(wstart>>8);
+		t.wstart[0]=0xff&wstart;
+		t.wend[3]=0xff&(wend>>24);
+		t.wend[2]=0xff&(wend>>16);
+		t.wend[1]=0xff&(wend>>8);
+		t.wend[0]=0xff&wend;
+		t.wstartm[3]=0xff&(wstartm>>24);
+		t.wstartm[2]=0xff&(wstartm>>16);
+		t.wstartm[1]=0xff&(wstartm>>8);
+		t.wstartm[0]=0xff&wstartm;
+		t.wendm[3]=0xff&(wendm>>24);
+		t.wendm[2]=0xff&(wendm>>16);
+		t.wendm[1]=0xff&(wendm>>8);
+		t.wendm[0]=0xff&wendm;
+		t.fadein[1]=0xff&(10>>8); /* XXX */
+		t.fadein[0]=0xff&10; /* XXX */
+		t.fadeout[1]=0xff&(50>>8); /* XXX */
+		t.fadeout[0]=0xff&50; /* XXX */
+		t.stlvl=99; /* XXX */
+		t.stmix=0x01; /* XXX */
+		t.midich1=16-1; /* XXX */
+		t.midinote=60; /* XXX */
+		t.startm=0x03; /* XXX */
+		t.predel[1]=0xff&(500>>8); /* XXX */
+		t.predel[0]=0xff&500; /* XXX */
+		t.outlvl=50; /* XXX */
+		t.sendlvl=25; /* XXX */
+		/* derive DD take name from WAV file name */
+		if (nlen>AKAI_NAME_LEN){
+			nlen=AKAI_NAME_LEN;
+		}
+		bcopy(wavname,name,nlen);
+		name[nlen]='\0';
+		ascii2akai_name(name,t.name,0); /* 0: not S900 */
+	}
+	/* fundamental settings of DD take */
+	t.stat=AKAI_DDTAKESTAT_USED; /* used */
+	/* set cstarts and cstarte in DD take header */
+	t.cstarts[1]=0xff&(cstarts>>8);
+	t.cstarts[0]=0xff&cstarts;
+	t.cstarte[1]=0xff&(cstarte>>8);
+	t.cstarte[0]=0xff&cstarte;
+	t.stype=(wavchnr==2)?AKAI_DDTAKESTYPE_STEREO:AKAI_DDTAKESTYPE_MONO;
+	t.srate[1]=0xff&(samplerate>>8);
+	t.srate[0]=0xff&samplerate;
+
+	/* copy DD take header into directory entry */
+	bcopy(&t,&pp->head.dd.take[ti],sizeof(struct akai_ddtake_s));
+	/* write partition header */
+	if (akai_io_blks(pp,(u_char *)&pp->head.dd,
+					 0,
+					 AKAI_DDPARTHEAD_BLKS,
+					 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+		PRINTF_ERR("cannot write partition header\n");
+		goto akai_wav2take_exit;
+	}
+
+#if 1
+	PRINTF_OUT("DD take imported from WAV\n");
+#endif
+
+	ret=0; /* success */
+
+akai_wav2take_exit:
+	if (what&WAV2TAKE_OPEN){
+		if (wavfd>=0){
+			CLOSE(wavfd);
+		}
+	}
+	if (bcountp!=NULL){
+		*bcountp=bcount;
+	}
+	if (envbuf!=NULL){
+		free(envbuf);
+	}
+	if (wavbuf!=NULL){
+		free(wavbuf);
+	}
+	return ret;
+}
+
+
+
+/* set envelope for take */
+int
+akai_take_setenv(struct part_s *pp,u_int cstarts,u_int samplesize,u_char *envbuf,u_int envsiz)
+{
+	static u_char logabstab[0x100]; /* must be static */
+	static int logabstabready=0; /* must be static */
+	u_char l,lmax;
+	u_int i,j;
+	u_int ba,bremain,bchunk,la,lchunk;
+	static u_char sbuf[AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE]; /* 1 cluster */
+
+	if (!logabstabready){ /* logabstab not initialized yet? */
+		double lconst;
+
+		/* initialize logabstab */
+		lconst=((double)(AKAI_DDTAKE_ENVMAXVAL-1))/log((double)0x80);
+		logabstab[0x00]=0;
+		for (i=0x01;i<=0x7f;i++){
+			logabstab[i]=((u_char)(lconst*log((double)i)))+1;
+		}
+		logabstab[0x80]=AKAI_DDTAKE_ENVMAXVAL;
+		for (i=0x81;i<=0xff;i++){
+			logabstab[i]=logabstab[0x100-i];
+		}
+
+		logabstabready=1; /* logabstab is initialized */
+	}
+
+	if ((pp==NULL)||(!pp->valid)||(pp->fat==NULL)){
+		return -1;
+	}
+	if (pp->type!=PART_TYPE_DD){
+		return -1;
+	}
+
+	if (envbuf==NULL){
+		return -1;
+	}
+
+	/* zero envbuf */
+	bzero(envbuf,envsiz);
+
+	if (samplesize==0){
+		return 0;
+	}
+
+	/* calculate envelope of samples */
+	ba=0;
+	bremain=samplesize;
+	i=0;
+	while ((bremain>0)&&(i<envsiz)){
+		/* cluster */
+		bchunk=AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE;
+		if (bchunk>bremain){
+			bchunk=bremain;
+		}
+
+		/* read samples from take */
+		if (akai_export_ddfatchain(pp,cstarts,ba,bchunk,-1,sbuf)<0){
+			PRINTF_ERR("cannot read take\n");
+#if 1
+			break;
+#else
+			return -1;
+#endif
+		}
+
+		la=0;
+		while ((bchunk>0)&&(i<envsiz)){
+			/* envelope block */
+			lchunk=AKAI_DDTAKE_ENVBLKSIZW<<1; /* *2 for 16bit per sample word */
+			if (lchunk>bchunk){
+				lchunk=bchunk;
+			}
+			/* determine peak level within envelope block */
+			lmax=0;
+			for (j=0;j<lchunk;j+=2){ /* 2 for 16bit per sample word */
+				l=logabstab[sbuf[la+j+1]]; /* logabs of MSB */
+				if (l>lmax){
+					lmax=l;
+				}
+			}
+			envbuf[i]=lmax;
+
+			ba+=lchunk;
+			bremain-=lchunk;
+			la+=lchunk;
+			bchunk-=lchunk;
+			i++;
+		}
+	}
+
+	return 0;
+}
+
+
+
+/* EOF */
diff --git a/third_party/akaiutil/akaiutil_take.h b/third_party/akaiutil/akaiutil_take.h
new file mode 100755
index 0000000..440f383
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_take.h
@@ -0,0 +1,68 @@
+#ifndef __AKAIUTIL_TAKE_H
+#define __AKAIUTIL_TAKE_H
+/*
+* Copyright (C) 2012,2018,2019 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+#include "akaiutil.h"
+
+
+
+/* AKAI DD takes */
+
+/* Note: all data types are little endian */
+
+
+
+/* S1100/S3000 DD take header (directory entry in DD partition header) */
+/* XXX should be defined in akaiutil_take.h, but must be in akaiutil.h due to dependencies */
+struct akai_ddtake_s;
+
+
+
+/* file name ending for exported DD take */
+#define AKAI_DDTAKE_FNAMEEND	".TK"
+
+
+
+/* Declarations */
+
+extern int akai_ddtake_info(struct part_s *pp,u_int ti,int verbose);
+
+extern int akai_import_take(int inpfd,struct part_s *pp,struct akai_ddtake_s *tp,u_int ti,u_int csizes,u_int csizee);
+
+extern int akai_export_take(int outfd,struct part_s *pp,struct akai_ddtake_s *tp,u_int csizes,u_int csizee,u_int cstarts,u_int cstarte);
+
+#define TAKE2WAV_CHECK		1
+#define TAKE2WAV_EXPORT		2
+#define TAKE2WAV_CREATE		4
+#define TAKE2WAV_ALL		0xff
+extern int akai_take2wav(struct part_s *pp,u_int ti,int wavfd,u_int *sizep,char **wavnamep,int what);
+
+#define WAV2TAKE_OPEN		1
+extern int akai_wav2take(int wavfd,char *wavname,struct part_s *pp,u_int ti,u_int *bcountp,int what);
+
+extern int akai_take_setenv(struct part_s *pp,u_int cstarts,u_int samplesize,u_char *envbuf,u_int envsiz);
+
+
+
+#endif /* !__AKAIUTIL_TAKE_H */
diff --git a/third_party/akaiutil/akaiutil_tar.c b/third_party/akaiutil/akaiutil_tar.c
new file mode 100755
index 0000000..c36e496
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_tar.c
@@ -0,0 +1,1235 @@
+/*
+* Copyright (C) 2008,2010,2012,2018,2019,2020,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+#include "akaiutil_io.h"
+#include "akaiutil.h"
+#include "akaiutil_file.h"
+#include "akaiutil_take.h"
+#include "akaiutil_tar.h"
+
+
+
+u_int
+tar_checksum(u_char *hp)
+{
+	u_int sum;
+	u_int i;
+	int zeroflag;
+
+	if (hp==NULL){
+		return 0;
+	}
+
+	sum=0;
+	zeroflag=1; /* still all zeroes */
+	for (i=0;i<sizeof(struct tar_head_s);i++){
+		if (hp[i]!=0){
+			zeroflag=0;
+		}
+		if ((i>=148)&&(i<156)){	/* treat chksum field */
+			sum+=(u_int)' '; /* space */
+		}else{
+			sum+=(u_int)hp[i];
+		}
+	}
+	/* Note: sum is always >0 !!! */
+
+	if (zeroflag){
+		sum=0; /* unique value, see comment above */
+	}
+	return sum;
+}
+
+int
+tar_export(int fd,struct disk_s *dp,struct part_s *pp,struct vol_s *vp,struct file_s *fp,u_int ti,u_int flags,int verbose,u_char *filtertagp)
+{
+	struct tar_head_s tarhd;
+	u_int chksum;
+	u_int size;
+	u_int n;
+	u_char buf[TAR_BLOCKSIZE];
+	int wavret;
+	char *wavname;
+	int wavconvflag;
+
+	/* DD take */
+	u_int ddcstarts,ddcstarte;
+	u_int ddcsizes,ddcsizee;
+	struct akai_ddtake_s ddt;
+
+	if (fd<0){
+		return -1;
+	}
+	if ((flags&(TAR_EXPORT_DISK|TAR_EXPORT_PART|TAR_EXPORT_VOL|TAR_EXPORT_ANYFILE))==0){
+		return -1;
+	}
+
+	size=0;
+
+	ddcstarts=0;
+	ddcstarte=0;
+	ddcsizes=0;
+	ddcsizee=0;
+
+	wavconvflag=0;
+
+	/* create tar header */
+	bzero(&tarhd,sizeof(struct tar_head_s));
+	
+	/* name */
+	/* XXX should always fit */
+	if (flags&TAR_EXPORT_DISK){
+		/* disk */
+		if (dp==NULL){
+			return -1;
+		}
+		sprintf(tarhd.name,"disk%u/",dp->index);
+	}
+	if (flags&TAR_EXPORT_PART){
+		/* partition */
+		if (pp==NULL){
+			return -1;
+		}
+		if (pp->type==PART_TYPE_DD){
+			/* harddisk DD partition */
+			if (pp->letter==0){
+				sprintf(tarhd.name+strlen(tarhd.name),"DD/");
+			}else{
+				sprintf(tarhd.name+strlen(tarhd.name),"DD%u/",(u_int)pp->letter);
+			}
+		}else{
+			/* sampler partition */
+			sprintf(tarhd.name+strlen(tarhd.name),"%c/",pp->letter);
+		}
+	}
+	if (flags&TAR_EXPORT_VOL){
+		/* sampler volume */
+		if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)){
+			return -1;
+		}
+		sprintf(tarhd.name+strlen(tarhd.name),"%s/",vp->name);
+		if ((flags&TAR_EXPORT_ANYFILE)==0){ /* not a file? */
+			/* XXX use devmajor field for type */
+			sprintf(tarhd.devmajor,"%07o",vp->type);
+			/* XXX use devminor field for load number */
+			sprintf(tarhd.devminor,"%07o",vp->lnum);
+#ifndef TAR_NOVOLPARAMTARHD
+			if (vp->param!=NULL){
+				/* XXX use linkname for volume parameters */
+				tarhd.linkname[0]='\0'; /* XXX magic, also empty linkname string */
+				tarhd.linkname[1]='P'; /* XXX magic */
+				bcopy(vp->param,
+					&tarhd.linkname[0]+2, /* XXX +2: linkname starts with magic */
+					sizeof(struct akai_volparam_s)); /* XXX should fit */
+			}
+#endif
+		}
+	}
+	if (flags&TAR_EXPORT_DDFILE){
+		/* DD take */
+		if (flags&TAR_EXPORT_WAV){
+			wavret=akai_take2wav(pp,ti,fd,&size,&wavname,TAKE2WAV_CHECK);
+			if (wavret<0){ /* error? */
+#if 1
+				return 0; /* skip this file w/o error */
+#else
+				return -1;
+#endif
+			}
+			strcpy(tarhd.name+strlen(tarhd.name),wavname);
+			wavconvflag=1;
+		}
+		if (!wavconvflag){
+			char fnamebuf[AKAI_NAME_LEN+4+1]; /* name (ASCII), +4 for ".<type>", +1 for '\0' */
+
+			/* index */
+			if (ti>=AKAI_DDTAKE_MAXNUM){
+				return 0; /* skip this file w/o error */
+			}
+			if (pp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+				return 0; /* skip this file w/o error */
+			}
+
+			/* clusters */
+			ddcstarts=(pp->head.dd.take[ti].cstarts[1]<<8)
+					  +pp->head.dd.take[ti].cstarts[0];
+			ddcstarte=(pp->head.dd.take[ti].cstarte[1]<<8)
+					  +pp->head.dd.take[ti].cstarte[0];
+
+			/* determine csizes (sample clusters) and csizee (envelope clusters) */
+			if (ddcstarts!=0){ /* sample not empty? */
+				ddcsizes=akai_count_ddfatchain(pp,ddcstarts);
+			}else{
+				ddcsizes=0;
+			}
+			if (ddcstarte!=0){ /* envelope not empty? */
+				ddcsizee=akai_count_ddfatchain(pp,ddcstarte);
+			}else{
+				ddcsizee=0;
+			}
+
+			/* name */
+			akai2ascii_name(pp->head.dd.take[ti].name,fnamebuf,0); /* 0: not S900 */
+			strcpy(fnamebuf+strlen(fnamebuf),AKAI_DDTAKE_FNAMEEND);
+			strcpy(tarhd.name+strlen(tarhd.name),fnamebuf);
+
+			/* get DD take header (DD directory entry) */
+			bcopy(&pp->head.dd.take[ti],&ddt,sizeof(struct akai_ddtake_s));
+			/* XXX use cstarts/cstarte fields in DD take header for csizes/csizee */
+			ddt.cstarts[1]=0xff&(ddcsizes>>8);
+			ddt.cstarts[0]=0xff&ddcsizes;
+			ddt.cstarte[1]=0xff&(ddcsizee>>8);
+			ddt.cstarte[0]=0xff&ddcsizee;
+			/* size in bytes */
+			size=sizeof(struct akai_ddtake_s)+(ddcsizes+ddcsizee)*AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE;
+		}
+	}
+	if (flags&TAR_EXPORT_FILE){
+		/* sampler file */
+		if ((fp==NULL)||(fp->type==AKAI_FTYPE_FREE)){
+			return -1;
+		}
+		/* test if tag-filter matches */
+		if (akai_match_filetags(filtertagp,fp->tag)<0){ /* no match? */
+			return 0; /* skip this file w/o error */
+		}
+		if (flags&TAR_EXPORT_WAV){
+			wavret=akai_sample2wav(fp,fd,&size,&wavname,SAMPLE2WAV_CHECK);
+			if (wavret<0){ /* error? */
+#if 1
+				return 0; /* skip this file w/o error */
+#else
+				return -1;
+#endif
+			}
+			if (wavret==0){
+				/* file is a valid sample file */
+				strcpy(tarhd.name+strlen(tarhd.name),wavname);
+				wavconvflag=1;
+			} /* else: file is not a sample file, export without WAV conversion */
+		}
+		if (!wavconvflag){
+			strcpy(tarhd.name+strlen(tarhd.name),fp->name);
+			size=fp->size;
+		}
+		/* XXX use devmajor field for osver */
+		if (wavconvflag&&(fp->type==AKAI_SAMPLE900_FTYPE)){ /* WAV conversion of S900 sample file? */
+			/* WAV is non-compressed, must use osver for S900 non-compressed sample format */
+			sprintf(tarhd.devmajor,"%07o",AKAI_OSVER_S900VOL); /* XXX */
+		}else{
+			sprintf(tarhd.devmajor,"%07o",fp->osver); /* XXX */
+		}
+		if ((fp->volp!=NULL)
+			&&((fp->volp->type==AKAI_VOL_TYPE_S3000)||(fp->volp->type==AKAI_VOL_TYPE_CD3000))){
+			/* XXX use linkname for file tags */
+			tarhd.linkname[0]='\0'; /* XXX magic, also empty linkname string */
+			tarhd.linkname[1]='T'; /* XXX magic */
+			bcopy(fp->tag,
+				&tarhd.linkname[0]+2, /* XXX +2: linkname starts with magic */
+				AKAI_FILE_TAGNUM); /* XXX should fit */
+		}
+	}
+#ifndef TAR_NOTAGSFILE
+#ifndef TAR_TAGSFILENAME
+#define TAR_TAGSFILENAME	"TAGS.DAT"
+#endif
+	if (flags&TAR_EXPORT_TAGSFILE){
+		/* tags-file */
+		if ((pp==NULL)||(pp->type!=PART_TYPE_HD) /* not in S1000/S3000 harddisk partition on partition level? */
+			||(strncmp(AKAI_PARTHEAD_TAGSMAGIC,(char *)pp->head.hd.tagsmagic,4)!=0)){
+#if 1
+			return 0; /* skip this file w/o error */
+#else
+			return -1;
+#endif
+		}
+		strcpy(tarhd.name+strlen(tarhd.name),TAR_TAGSFILENAME);
+		size=4+AKAI_PARTHEAD_TAGNUM*AKAI_NAME_LEN; /* tags magic and tag names */;
+	}
+#endif
+#ifndef TAR_NOVOLPARAMFILE
+#ifndef TAR_VOLPARAMFILENAME
+#define TAR_VOLPARAMFILENAME	"VOLPARAM.DAT"
+#endif
+	if (flags&TAR_EXPORT_VOLPARAMFILE){
+		/* volparam-file */
+		if ((vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)||(vp->param==NULL)){
+#if 1
+			return 0; /* skip this file w/o error */
+#else
+			return -1;
+#endif
+		}
+		strcpy(tarhd.name+strlen(tarhd.name),TAR_VOLPARAMFILENAME);
+		size=sizeof(struct akai_volparam_s);
+	}
+#endif
+
+	if (verbose){
+		PRINTF_OUT("%s\n",tarhd.name);
+		FLUSH_ALL;
+	}
+
+	/* mode, uid, gid */
+	if (flags&TAR_EXPORT_ANYFILE){ /* file? */
+		sprintf(tarhd.mode,"%07o",0600); /* XXX -rw------- */
+	}else{
+		/* directory */
+		sprintf(tarhd.mode,"%07o",0700); /* XXX -rwx------ */
+	}
+	sprintf(tarhd.uid,"%07o",0); /* XXX */
+	sprintf(tarhd.gid,"%07o",0); /* XXX */
+
+	/* size */
+	sprintf(tarhd.size,"%011o",size);
+
+	/* mtime */
+	sprintf(tarhd.mtime,"%011o",(u_int)time(NULL)); /* XXX */
+
+	/* space */
+	tarhd.space=' ';
+
+	/* type */
+	if (flags&TAR_EXPORT_ANYFILE){ /* file? */
+		tarhd.type=TAR_TYPE_REG;
+	}else{
+		/* directory */
+		tarhd.type=TAR_TYPE_DIR;
+	}
+
+	/* magic */
+	bcopy(TAR_USTAR,tarhd.ustar,8);
+
+	/* user name */
+#ifndef TAR_UNAME
+#define TAR_UNAME	"AKAI"
+#endif
+	strcpy(tarhd.uname,TAR_UNAME);
+	/* group name */
+#ifndef TAR_GNAME
+#define TAR_GNAME	"AKAI"
+#endif
+	strcpy(tarhd.gname,TAR_GNAME);
+	
+	/* checksum */
+	chksum=tar_checksum((u_char *)&tarhd);
+	sprintf(tarhd.chksum,"%06o",chksum);
+	
+	/* write tar header */
+	if (WRITE(fd,(void *)&tarhd,sizeof(struct tar_head_s))!=sizeof(struct tar_head_s)){
+		PRINTF_ERR("cannot write tar header\n");
+		return -1;
+	}
+
+	if ((flags&TAR_EXPORT_ANYFILE)==0){ /* not a file? */
+		return 0; /* done */
+	}
+
+	if (flags&TAR_EXPORT_DDFILE){
+		/* export DD take */
+		if (wavconvflag){
+			if (akai_take2wav(pp,ti,fd,NULL,NULL,SAMPLE2WAV_EXPORT)<0){
+				return -1;
+			}
+		}else{
+			if (akai_export_take(fd,pp,&ddt,ddcsizes,ddcsizee,ddcstarts,ddcstarte)<0){
+				PRINTF_ERR("cannot export take\n");
+				return -1;
+			}
+		}
+	}
+
+	if (flags&TAR_EXPORT_FILE){
+		/* export sampler file */
+		if (wavconvflag){
+			if (akai_sample2wav(fp,fd,NULL,NULL,SAMPLE2WAV_EXPORT)<0){
+				return -1;
+			}
+		}else{
+			if (akai_read_file(fd,NULL,fp,0,fp->size)<0){
+				return -1;
+			}
+		}
+	}
+
+#ifndef TAR_NOTAGSFILE
+	if (flags&TAR_EXPORT_TAGSFILE){
+		/* export tags-file */
+		if (WRITE(fd,(void *)pp->head.hd.tagsmagic,size)!=(int)size){
+			PRINTF_ERR("cannot export tags-file\n");
+			return -1;
+		}
+	}
+#endif
+#ifndef TAR_NOVOLPARAMFILE
+	if (flags&TAR_EXPORT_VOLPARAMFILE){
+		/* export volparam-file */
+		if (WRITE(fd,(void *)vp->param,size)!=(int)size){
+			PRINTF_ERR("cannot export volparam-file\n");
+			return -1;
+		}
+	}
+#endif
+
+	/* fill rest of TAR_BLOCKSIZE bytes */
+	n=size%TAR_BLOCKSIZE;
+	n=(TAR_BLOCKSIZE-n)%TAR_BLOCKSIZE;
+	if (n>0){
+		bzero(buf,n);
+		/* write */
+		if (WRITE(fd,(void *)buf,n)!=(int)n){
+			PRINTF_ERR("cannot write rest of block\n");
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int
+tar_export_vol(int fd,struct vol_s *vp,u_int flags,int verbose,u_char *filtertagp)
+{
+	u_int fi;
+	struct file_s tmpfile; /* current file */
+
+	if ((fd<0)||(vp==NULL)||(vp->type==AKAI_VOL_TYPE_INACT)||(vp->partp==NULL)||(!vp->partp->valid)){
+		return -1;
+	}
+
+#ifndef TAR_NOVOLPARAMFILE
+	if (vp->param!=NULL){
+		/* export volparam-file */
+		if (tar_export(fd,vp->partp->diskp,vp->partp,vp,NULL,0,flags|TAR_EXPORT_VOLPARAMFILE,verbose,NULL)){
+			return -1;
+		}
+	}
+#endif
+
+	/* files in volume directory */
+	for (fi=0;fi<vp->fimax;fi++){
+		/* get file */
+		if (akai_get_file(vp,&tmpfile,fi)<0){
+			continue; /* XXX ignore error, next file */
+		}
+#if 1
+		if (akai_check_fatblk(tmpfile.bstart,vp->partp->bsize,vp->partp->bsyssize)<0){ /* invalid? */
+			if (verbose){
+				PRINTF_OUT("file %u has invalid start block, skipping file\n",tmpfile.index+1);
+				FLUSH_ALL;
+			}
+			continue; /* XXX ignore error, next file */
+		}
+#endif
+
+		/* export [part/volume/]file */
+		if (tar_export(fd,vp->partp->diskp,vp->partp,vp,&tmpfile,0,flags|TAR_EXPORT_FILE,verbose,filtertagp)){
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int
+tar_export_part(int fd,struct part_s *pp,u_int flags,int verbose,u_char *filtertagp)
+{
+	u_int vi;
+	struct vol_s tmpvol; /* current volume */
+
+	if ((fd<0)||(pp==NULL)||(!pp->valid)){
+		return -1;
+	}
+
+	if (pp->type==PART_TYPE_DD){
+		/* harddisk DD partition */
+		/* export all DD takes */
+		u_int ti;
+
+		for (ti=0;ti<AKAI_DDTAKE_MAXNUM;ti++){
+			if (pp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+				continue; /* next */
+			}
+			if (tar_export(fd,pp->diskp,pp,NULL,NULL,ti,flags|TAR_EXPORT_DDFILE,verbose,filtertagp)){
+				return -1;
+			}
+		}
+	}
+
+	/* now, sampler partition */
+
+#ifndef TAR_NOTAGSFILE
+	if (pp->type==PART_TYPE_HD){ /* in S1000/S3000 harddisk partition? */
+		/* export tags-file */
+		/* Note: tar_export() will check for valid tags magic */
+		if (tar_export(fd,pp->diskp,pp,NULL,NULL,0,flags|TAR_EXPORT_TAGSFILE,verbose,NULL)){
+			return -1;
+		}
+	}
+#endif
+
+	/* volumes in root directory of partition */
+	for (vi=0;vi<pp->volnummax;vi++){
+		/* get volume */
+		if (akai_get_vol(pp,&tmpvol,vi)<0){
+			continue; /* XXX ignore error, next volume */
+		}
+		if ((tmpvol.type!=AKAI_VOL_TYPE_S900)
+			&&(tmpvol.type!=AKAI_VOL_TYPE_S1000)
+			&&(tmpvol.type!=AKAI_VOL_TYPE_S3000)
+			&&(tmpvol.type!=AKAI_VOL_TYPE_CD3000)){
+			continue; /* next volume */
+		}
+		/* create vol/ */
+		if (tar_export(fd,pp->diskp,pp,&tmpvol,NULL,0,flags|TAR_EXPORT_VOL,verbose,NULL)){
+			return -1;
+		}
+		/* export volume */
+		if (tar_export_vol(fd,&tmpvol,flags|TAR_EXPORT_VOL,verbose,filtertagp)<0){
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int
+tar_export_disk(int fd,struct disk_s *dp,u_int flags,int verbose,u_char *filtertagp)
+{
+	u_int pi;
+
+	if ((fd<0)||(dp==NULL)){
+		return -1;
+	}
+
+	/* partitions on disk */
+	for (pi=0;pi<part_num;pi++){
+		if (part[pi].diskp!=dp){ /* partition not on disk? */
+			continue; /* next partition */
+		}
+		/* create part/ */
+		if (tar_export(fd,part[pi].diskp,&part[pi],NULL,NULL,0,flags|TAR_EXPORT_PART,verbose,NULL)){
+			return -1;
+		}
+		/* export partition (sampler or DD) */
+		if (tar_export_part(fd,&part[pi],flags|TAR_EXPORT_PART,verbose,filtertagp)<0){
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int
+tar_export_alldisks(int fd,u_int flags,int verbose,u_char *filtertagp)
+{
+	u_int i;
+
+	if (fd<0){
+		return -1;
+	}
+
+	/* all disks */
+	for (i=0;i<disk_num;i++){
+		/* create disk/ */
+		if (tar_export(fd,&disk[i],NULL,NULL,NULL,0,flags|TAR_EXPORT_DISK,verbose,NULL)){
+			return -1;
+		}
+		/* export disk */
+		if (tar_export_disk(fd,&disk[i],flags|TAR_EXPORT_DISK,verbose,filtertagp)<0){
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+int
+tar_export_curdir(int fd,int verbose,u_int flags)
+{
+
+	if (fd<0){
+		return -1;
+	}
+
+	if (curdiskp==NULL){ /* no disk? */
+		/* now, on system level */
+		return tar_export_alldisks(fd,flags,verbose,curfiltertag);
+	}
+	if (curpartp==NULL){ /* no partition? */
+		/* now, on disk */
+		return tar_export_disk(fd,curdiskp,flags,verbose,curfiltertag);
+	}
+	if (curvolp==NULL){ /* no sampler volume? */
+		/* now, in partition (sampler or DD) */
+		return tar_export_part(fd,curpartp,flags,verbose,curfiltertag);
+	}
+	/* now, in sampler volume */
+	return tar_export_vol(fd,curvolp,flags,verbose,curfiltertag);
+}
+
+int
+tar_export_tailzero(int fd)
+{
+	u_char buf[TAR_TAILZERO_BLOCKS*TAR_BLOCKSIZE];
+
+	/* zero blocks */
+	bzero(buf,TAR_TAILZERO_BLOCKS*TAR_BLOCKSIZE);
+
+	/* write blocks */
+	if (WRITE(fd,buf,TAR_TAILZERO_BLOCKS*TAR_BLOCKSIZE)!=TAR_TAILZERO_BLOCKS*TAR_BLOCKSIZE){
+		PRINTF_ERR("cannot write zero blocks\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+
+
+int
+tar_import_curdir(int fd,u_int vtype0,int verbose,u_int flags)
+{
+	struct tar_head_s tarhd;
+	u_int byteend,skip;
+	u_int chksum,chksum0;
+	u_int nlen;
+	u_int l;
+	int i;
+	int ret;
+	struct vol_s tmpvol;
+	struct file_s tmpfile;
+	u_int vtype,lnum;
+	u_int ftype;
+	u_int osver;
+	u_char *tagp;
+	struct akai_volparam_s *parp;
+	u_int wavbcount;
+	int wavret;
+	u_int ti;
+	u_int csizes,csizee;
+	u_int tsize;
+	struct akai_ddtake_s t;
+
+	save_curdir(1); /* 1: could be modifications */
+
+	/* interpret tar file */
+	skip=0;
+	ret=-1; /* no success so far */
+	for (;;){
+		if (verbose){
+			FLUSH_ALL;
+		}
+		restore_curdir();
+
+		/* skip if necessary */
+		if (skip>0){
+			/* skip file */
+			if (LSEEK64(fd,(OFF64_T)skip,SEEK_CUR)<0){
+				PERROR("lseek");
+				ret=-1;
+				goto tar_import_done;
+			}
+		}
+		skip=0;
+
+		/* read header */
+		/* XXX size must not exceed SSIZE_MAX! */
+		ret=(int)READ(fd,(void *)&tarhd,sizeof(struct tar_head_s));
+		if (ret==0){
+			/* end of file */
+			ret=0; /* success */
+			goto tar_import_done;
+		}else if (ret!=sizeof(struct tar_head_s)){
+			PRINTF_ERR("cannot read tar header\n");
+			ret=-1;
+			goto tar_import_done;
+		}
+
+		/* check header */
+		chksum0=tar_checksum((u_char *)&tarhd);
+		if (chksum0==0){ /* all zero block? */
+			/* XXX ignore */
+			continue; /* next */
+		}
+		/* checksum */
+		if ((sscanf(tarhd.chksum,"%o",&chksum)!=1)||(chksum!=chksum0)){
+			PRINTF_OUT("checksum error in next header\n");
+			FLUSH_ALL;
+			ret=-1;
+			goto tar_import_done;
+		}
+
+		/* get size */
+		byteend=0; /* default */
+		sscanf(tarhd.size,"%o",&byteend);
+		/* Note: if sscanf finds nothing, vtype remains! */
+		/* skip rest of full TAR_BLOCKSIZE */
+		skip=byteend%TAR_BLOCKSIZE;
+		skip=(TAR_BLOCKSIZE-skip)%TAR_BLOCKSIZE;
+
+		/* check type */
+		if ((tarhd.type!=TAR_TYPE_DIR)
+			&&(tarhd.type!=TAR_TYPE_REG)
+			&&(tarhd.type!=TAR_TYPE_REG0)){
+			skip+=byteend; /* skip file */
+			continue; /* next */
+		}
+		/* now, directory or regular file */
+
+		/* get name */
+		if (verbose){
+			PRINTF_OUT("%s\n",tarhd.name);
+			FLUSH_ALL;
+		}
+		l=(u_int)strlen(tarhd.name);
+		/* correct name if directory */
+		if ((tarhd.type==TAR_TYPE_DIR)&&(l>0)&&(tarhd.name[l-1]=='/')){
+			tarhd.name[l-1]='\0'; /* terminate */
+			l--;
+		}
+		if (l==0){
+			if (verbose){
+				PRINTF_OUT("empty name, skipping file\n");
+				FLUSH_ALL;
+			}
+			skip+=byteend; /* skip file */
+			continue; /* next */
+		}
+
+		/* XXX ignore other tarhd elements */
+
+		/* change to upper level directory */
+		/* Note: will be undone upon exit or next for-loop iteration */
+		save_curdir(1); /* 1: could be modifications */
+		if (change_curdir(tarhd.name,0,dirnamebuf,0)<0){
+			PRINTF_ERR("directory not found\n");
+			ret=-1;
+			goto tar_import_done;
+		}
+
+		/* parse type further */
+		if (tarhd.type==TAR_TYPE_DIR){
+			/* directory */
+
+			if (curdiskp==NULL){
+				/* on system level */
+				/* Note: no need to create disk, but must check if exists!!! */
+				if ((strncasecmp(dirnamebuf,"disk",4)==0)&&(strlen(dirnamebuf)>=5)){
+					i=atoi(dirnamebuf+4);
+				}else{
+					i=-1; /* invalid */
+				}
+				if ((i<0)||(i>=(int)disk_num)){
+					PRINTF_ERR("disk does not exist\n");
+					ret=-1;
+					goto tar_import_done;
+				}	
+			}else if (curpartp==NULL){
+				/* on disk level */
+				/* Note: no need to create partition, but must check if exists!!! */
+				if (akai_find_part(curdiskp,dirnamebuf)==NULL){
+					PRINTF_ERR("partition does not exist\n");
+					ret=-1;
+					goto tar_import_done;
+				}	
+			}else{
+				/* on partition level */
+				if (curpartp->type==PART_TYPE_DD){
+					/* harddisk DD partition */
+					PRINTF_ERR("no directory allowed in DD-partition\n");
+					ret=-1;
+					goto tar_import_done;
+				}
+				/* now, sampler partition */
+				if (curvolp!=NULL){ /* already in volume? */
+					PRINTF_ERR("no directory allowed in volume\n");
+					ret=-1;
+					goto tar_import_done;
+				}
+				/* load number */
+				lnum=AKAI_VOL_LNUM_OFF; /* default */
+				/* XXX use devminor field for load number */
+				sscanf(tarhd.devminor,"%o",&lnum);
+				/* Note: if sscanf finds nothing, lnum remains! */
+				/* correct lnum */
+				if ((lnum!=AKAI_VOL_LNUM_OFF)
+					&&((lnum<AKAI_VOL_LNUM_MIN)||(lnum>AKAI_VOL_LNUM_MAX))){
+						lnum=AKAI_VOL_LNUM_OFF; /* XXX default */
+				}
+				/* volume parameters */
+				parp=NULL; /* default volume parameters or keep old ones */
+#ifndef TAR_NOVOLPARAMTARHD
+				/* XXX use linkname for volume parameters */
+				if ((tarhd.linkname[0]=='\0')&&(tarhd.linkname[1]=='P')){ /* XXX correct magic? */
+					parp=(struct akai_volparam_s *)(&tarhd.linkname[0]+2); /* XXX +2: linkname starts with magic */
+				}
+#endif
+				/* check if destination volume already exists */
+				if (akai_find_vol(curpartp,&tmpvol,dirnamebuf)<0){
+					/* does not exist (or error in finding it, don't care) */
+					/* user-supplied volume type, Note: will be corrected below if bad or inactive */
+					vtype=vtype0;
+					if (vtype0==AKAI_VOL_TYPE_INACT){ /* no user-supplied type? */
+						/* XXX use devmajor field for type */
+						sscanf(tarhd.devmajor,"%o",&vtype);
+						/* Note: if sscanf finds nothing, vtype remains! */
+						/* correct vtype */
+						if (curpartp->type==PART_TYPE_HD9){
+							vtype=AKAI_VOL_TYPE_S900;
+						}else if ((vtype!=AKAI_VOL_TYPE_S1000)
+							&&(vtype!=AKAI_VOL_TYPE_S3000)
+							&&(vtype!=AKAI_VOL_TYPE_CD3000)){
+								vtype=AKAI_VOL_TYPE_S1000; /* XXX default */
+						}
+					}
+
+					/* create volume */
+					if (akai_create_vol(curpartp,&tmpvol,vtype,AKAI_CREATE_VOL_NOINDEX,dirnamebuf,lnum,parp)<0){
+						PRINTF_ERR("cannot create volume\n");
+						ret=-1;
+						goto tar_import_done;
+					}
+				}else{
+					/* volume already exists */
+					/* Note: keep volume type (even if user-supplied type) */
+					/* XXX use devminor field for load number */
+					if (tarhd.devminor[0]==0x00){ /* no load number? */
+						lnum=tmpvol.lnum; /* keep old value */
+					}
+					osver=tmpvol.osver; /* keep old value */
+					/* update load number and optional volume parameters */
+					if (akai_rename_vol(&tmpvol,NULL,lnum,osver,parp)<0){
+						PRINTF_ERR("cannot update volume\n");
+						ret=-1;
+						goto tar_import_done;
+					}
+				}
+				if ((tmpvol.param!=NULL)&&(parp!=NULL)&&verbose){
+					PRINTF_OUT("volume parameters imported\n");
+					FLUSH_ALL;
+				}
+			}
+
+			skip+=byteend; /* skip file */
+			continue; /* next */
+		}
+		/* now, regular file */
+		nlen=(u_int)strlen(dirnamebuf);
+
+#ifndef TAR_NOTAGSFILE
+		/* handle tags-file */
+		if (strcmp(dirnamebuf,TAR_TAGSFILENAME)==0){
+			if ((curpartp!=NULL)&&(curpartp->type==PART_TYPE_HD)&&(curvolp==NULL)){ /* in S1000/S3000 harddisk partition on partition level? */
+				if (byteend==(4+AKAI_PARTHEAD_TAGNUM*AKAI_NAME_LEN)){ /* valid file size? (Note: tags magic and tag names) */
+					/* read tags-file into partition header */
+					if (READ(fd,(void *)curpartp->head.hd.tagsmagic,byteend)!=(int)byteend){
+						PRINTF_ERR("cannot read tags-file\n");
+						ret=-1;
+						goto tar_import_done;
+					}
+					/* XXX no check if valid tags magic */
+					/* write partition header */
+					if (akai_io_blks(curpartp,(u_char *)&curpartp->head.hd,
+									 0,
+									 AKAI_PARTHEAD_BLKS,
+									 1,IO_BLKS_WRITE)<0){ /* 1: allocate cache if possible */
+						PRINTF_ERR("cannot write partition header\n");
+						ret=-1;
+						goto tar_import_done;
+					}
+					if (verbose){
+						PRINTF_OUT("tags imported\n");
+						FLUSH_ALL;
+					}
+				}else{
+					if (verbose){
+						PRINTF_OUT("invalid file size of tags-file, skipping file\n");
+						FLUSH_ALL;
+					}
+					skip+=byteend; /* skip file */
+					continue; /* next */
+				}
+			}else{
+				if (verbose){
+					PRINTF_OUT("tags-file must be on partition level of S1000/S3000 harddisk, skipping file\n");
+					FLUSH_ALL;
+				}
+				skip+=byteend; /* skip file */
+				continue; /* next */
+			}
+			continue; /* next */
+		}
+#endif
+#ifndef TAR_NOVOLPARAMFILE
+		/* handle volparam-file */
+		if (strcmp(dirnamebuf,TAR_VOLPARAMFILENAME)==0){
+			if ((curvolp!=NULL)&&(curvolp->param!=NULL)){ /* on volume level and volume has parameters? */
+				if (byteend==sizeof(struct akai_volparam_s)){ /* valid file size? */
+					/* read volparam-file into volume */
+					if (READ(fd,(void *)curvolp->param,byteend)!=(int)byteend){
+						PRINTF_ERR("cannot read volparam-file\n");
+						ret=-1;
+						goto tar_import_done;
+					}
+					/* update volume */
+					if (akai_rename_vol(curvolp,NULL,curvolp->lnum,curvolp->osver,curvolp->param)<0){
+						PRINTF_ERR("cannot update volume\n");
+						ret=-1;
+						goto tar_import_done;
+					}
+					if ((curvolp->param!=NULL)&&verbose){
+						PRINTF_OUT("volume parameters imported\n");
+						FLUSH_ALL;
+					}
+				}else{
+					if (verbose){
+						PRINTF_OUT("invalid file size of volparam-file, skipping file\n");
+						FLUSH_ALL;
+					}
+					skip+=byteend; /* skip file */
+					continue; /* next */
+				}
+			}else{
+				if (verbose){
+					if (curvolp==NULL){
+						PRINTF_OUT("volparam-file must be on volume level, skipping file\n");
+					}else{
+						PRINTF_OUT("volume has no parameters, skipping file\n");
+					}
+					FLUSH_ALL;
+				}
+				skip+=byteend; /* skip file */
+				continue; /* next */
+			}
+			continue; /* next */
+		}
+#endif
+#ifndef TAR_NOVOLINFO1FILE
+#ifndef TAR_VOLINFO1FILENAME
+#define TAR_VOLINFO1FILENAME	"VOLINFO1.DAT"
+#endif
+#ifndef TAR_VOLINFO1FILE_SKIPB
+#define TAR_VOLINFO1FILE_SKIPB	0x0010 /* number of bytes to skip in volinfo1-file */
+#endif
+		/* handle volinfo1-file */
+		if (strcmp(dirnamebuf,TAR_VOLINFO1FILENAME)==0){
+			if ((curvolp!=NULL)&&(curvolp->param!=NULL)){ /* on volume level and volume has parameters? */
+				if (byteend==(TAR_VOLINFO1FILE_SKIPB+sizeof(struct akai_volparam_s))){ /* valid file size? */
+					if (LSEEK64(fd,(OFF64_T)TAR_VOLINFO1FILE_SKIPB,SEEK_CUR)<0){
+						PERROR("lseek");
+						ret=-1;
+						goto tar_import_done;
+					}
+					/* read volume parameters from volinfo1-file into volume */
+					l=sizeof(struct akai_volparam_s);
+					if (READ(fd,(void *)curvolp->param,l)!=(int)l){
+						PRINTF_ERR("cannot read volinfo1-file\n");
+						ret=-1;
+						goto tar_import_done;
+					}
+					/* update volume */
+					if (akai_rename_vol(curvolp,NULL,curvolp->lnum,curvolp->osver,curvolp->param)<0){
+						PRINTF_ERR("cannot update volume\n");
+						ret=-1;
+						goto tar_import_done;
+					}
+					if (verbose){
+						PRINTF_OUT("volume parameters imported\n");
+						FLUSH_ALL;
+					}
+				}else{
+					if (verbose){
+						PRINTF_OUT("invalid file size of volinfo1-file, skipping file\n");
+						FLUSH_ALL;
+					}
+					skip+=byteend; /* skip file */
+					continue; /* next */
+				}
+			}else{
+				if (verbose){
+					if (curvolp==NULL){
+						PRINTF_OUT("volinfo1-file must be on volume level, skipping file\n");
+					}else{
+						PRINTF_OUT("volume has no parameters, skipping file\n");
+					}
+					FLUSH_ALL;
+				}
+				skip+=byteend; /* skip file */
+				continue; /* next */
+			}
+			continue; /* next */
+		}
+#endif
+#ifndef TAR_NOSKIPDATFILE
+		/* skip dat-files */
+		if ((nlen>=4)&&(strncasecmp(dirnamebuf+nlen-4,".dat",4)==0)){
+			if (verbose){
+				PRINTF_OUT("skipping dat-file\n");
+				FLUSH_ALL;
+			}
+			skip+=byteend; /* skip file */
+			continue; /* next */
+		}
+#endif
+
+		if (curpartp==NULL){
+			PRINTF_ERR("no files allowed on disk level\n");
+			ret=-1;
+			goto tar_import_done;
+		}
+
+		if (curpartp->type==PART_TYPE_DD){
+			/* harddisk DD partition */
+
+			/* import DD take */
+
+			if ((flags&TAR_IMPORT_WAV)&&(nlen>=4)&&(strncasecmp(dirnamebuf+nlen-4,".wav",4)==0)){
+				/* convert WAV file into DD take */
+
+				/* find free index */
+				for (ti=0;ti<AKAI_DDTAKE_MAXNUM;ti++){
+					/* take */
+					if (curpartp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+						break; /* done */
+					}
+				}
+				if (ti==AKAI_DDTAKE_MAXNUM){ /* no free index? */
+					PRINTF_ERR("no free take index\n");
+					ret=-1;
+					goto tar_import_done;
+				}
+
+				/* Note: don't check if name already used, create new DD take */
+				wavret=akai_wav2take(fd,dirnamebuf,
+									 curpartp,
+									 ti,
+									 &wavbcount,
+									 0);
+				if ((wavret<0)||(byteend<wavbcount)){ /* error? */
+					ret=-1;
+					goto tar_import_done;
+				}
+				skip+=byteend-wavbcount; /* skip unread rest */
+				continue; /* file done, next */
+			}
+
+			/* check file name */
+			if ((nlen<3)||(strcmp(dirnamebuf+nlen-3,AKAI_DDTAKE_FNAMEEND)!=0)){
+					PRINTF_ERR("invalid file name for DD take, skipping file\n");
+					skip+=byteend; /* skip file */
+					continue; /* next */
+			}
+
+			/* find free index */
+			for (ti=0;ti<AKAI_DDTAKE_MAXNUM;ti++){
+				/* take */
+				if (curpartp->head.dd.take[ti].stat==AKAI_DDTAKESTAT_FREE){ /* free? */
+					break; /* done */
+				}
+			}
+			if (ti==AKAI_DDTAKE_MAXNUM){ /* no free index? */
+				PRINTF_ERR("no free take index\n");
+				ret=-1;
+				goto tar_import_done;
+			}
+
+			/* get DD take header (DD directory entry) */
+			if (READ(fd,&t,sizeof(struct akai_ddtake_s))!=(int)sizeof(struct akai_ddtake_s)){
+				PRINTF_ERR("cannot read DD take header\n");
+				ret=-1;
+				goto tar_import_done;
+			}
+
+			/* get csizes (sample clusters) and csizee (envelope clusters) */
+			/* XXX use cstarts/cstarte fields in DD take header for csizes/csizee */
+			csizes=(t.cstarts[1]<<8)
+				+t.cstarts[0];
+			csizee=(t.cstarte[1]<<8)
+				+t.cstarte[0];
+			/* Note: akai_import_take() will increase csizee if required */
+			/* XXX preliminary check of csizes+csizee */
+			if ((csizes+csizee)*AKAI_DDPART_CBLKS>curpartp->bfree){
+				PRINTF_ERR("not enough space left\n");
+				ret=-1;
+				goto tar_import_done;
+			}
+			/* size in bytes */
+			tsize=sizeof(struct akai_ddtake_s)+(csizes+csizee)*AKAI_DDPART_CBLKS*AKAI_HD_BLOCKSIZE;
+			if (tsize>byteend){
+				PRINTF_ERR("inconsistent size\n");
+				ret=-1;
+				goto tar_import_done;
+			}
+
+			/* import take */
+			/* Note: akai_import_take() will increase csizee if required */
+			/* Note: akai_import_take() keeps name in DD take header */
+			/* Note: don't check if name already used, create new DD take */
+			if (akai_import_take(fd,curpartp,&t,ti,csizes,csizee)<0){
+				PRINTF_ERR("cannot import take\n");
+				ret=-1;
+				goto tar_import_done;
+			}
+
+			/* skip unread rest */
+			skip+=byteend-tsize;
+			continue; /* next */
+		}
+
+		/* now, sampler partition */
+
+		if (curvolp==NULL){ /* not in volume? */
+			PRINTF_ERR("files only allowed in volume\n");
+			ret=-1;
+			goto tar_import_done;
+		}
+#if 0
+		skip+=byteend; /* skip file */
+		continue; /* next */
+#endif
+
+		/* import file */
+
+		/* default osver */
+		osver=curvolp->osver; /* default: from volume */
+		if (vtype0==AKAI_VOL_TYPE_INACT){ /* no user-supplied type? */
+			/* XXX use devmajor field for osver */
+			sscanf(tarhd.devmajor,"%o",&osver);
+		}else if (vtype0==AKAI_VOL_TYPE_S900){
+			osver=0; /* non-compressed, akai_create_file() will correct osver if necessary */
+		}else if ((vtype0==AKAI_VOL_TYPE_S3000)||(vtype0==AKAI_VOL_TYPE_CD3000)){
+			osver=AKAI_OSVER_S3000MAX; /* XXX */
+		}else{
+			osver=AKAI_OSVER_S1000MAX; /* XXX */
+		}
+		/* Note: if sscanf finds nothing, osver remains! */
+		/* default tags */
+		tagp=NULL;
+		if ((curvolp->type==AKAI_VOL_TYPE_S3000)||(curvolp->type==AKAI_VOL_TYPE_CD3000)){
+			/* XXX use linkname for file tags */
+			if ((tarhd.linkname[0]=='\0')&&(tarhd.linkname[1]=='T')){ /* XXX correct magic? */
+				tagp=(u_char *)&tarhd.linkname[2];/* XXX +2: linkname starts with magic */
+				/* XXX no check for valid tag entries */
+				akai_sort_filetags(tagp);
+			}
+		}
+
+		if ((flags&TAR_IMPORT_WAV)&&(nlen>=4)&&(strncasecmp(dirnamebuf+nlen-4,".wav",4)==0)){
+			/* convert WAV file into sample file */
+
+			/* sample file type */
+			if (flags&(TAR_IMPORT_WAVS9|TAR_IMPORT_WAVS9C)){
+				/* S900 sample */
+				ftype=AKAI_SAMPLE900_FTYPE;
+			}else if (flags&TAR_IMPORT_WAVS1){
+				/* S1000 sample */
+				ftype=AKAI_SAMPLE1000_FTYPE;
+			}else if (flags&TAR_IMPORT_WAVS3){
+				/* S3000 sample */
+				ftype=AKAI_SAMPLE3000_FTYPE;
+			}else{
+				ftype=AKAI_FTYPE_FREE; /* invalid: derive sample file type from volume type/file osver */
+				/* Note: if S900 sample, use non-compressed sample format */
+			}
+
+			/* Note: akai_wav2sample() will correct osver if necessary */
+			wavret=akai_wav2sample(fd,dirnamebuf,
+								   curvolp,
+								   AKAI_CREATE_FILE_NOINDEX,
+								   ftype,
+								   (flags&TAR_IMPORT_WAVS9C)?1:0, /* if S900 sample, use compressed/non-compressed sample format */
+								   osver,
+								   tagp,
+								   &wavbcount,
+								   WAV2SAMPLE_OVERWRITE);
+			if ((wavret<0)||(byteend<wavbcount)){ /* error? */
+				ret=-1;
+				goto tar_import_done;
+			}
+			skip+=byteend-wavbcount; /* skip unread rest */
+			continue; /* file done, next */
+		}
+
+#if 1
+		{
+			static u_char anamebuf[AKAI_NAME_LEN+4+1]; /* +4 for ".<type>", +1 for '\0' */
+			u_int osver;
+
+			/* skip file with invalid name/type */
+			if (ascii2akai_filename(dirnamebuf,anamebuf,&osver,curvolp->type==AKAI_VOL_TYPE_S900)==AKAI_FTYPE_FREE){
+				if (verbose){
+					PRINTF_OUT("invalid file name/type, skipping file\n");
+					FLUSH_ALL;
+				}
+				skip+=byteend; /* skip file */
+				continue; /* next */
+			}
+		}
+#endif
+		/* check if destination file already exists */
+		if (akai_find_file(curvolp,&tmpfile,dirnamebuf)==0){
+			/* exists */
+			/* delete file */
+			if (akai_delete_file(&tmpfile)<0){
+				PRINTF_ERR("cannot overwrite existing file\n");
+				ret=-1;
+				goto tar_import_done;
+			}
+		}
+		/* create destination file */
+		/* Note: akai_create_file() will correct osver if necessary */
+		if (akai_create_file(curvolp,
+			&tmpfile,
+			byteend,
+			AKAI_CREATE_FILE_NOINDEX,
+			dirnamebuf,
+			osver,
+			tagp)<0){
+				PRINTF_ERR("cannot create file\n");
+				ret=-1;
+				goto tar_import_done;
+		}
+		/* import file */
+		if (akai_write_file(fd,NULL,&tmpfile,0,tmpfile.size)<0){
+			ret=-1;
+			goto tar_import_done;
+		}
+		if ((curvolp->type==AKAI_VOL_TYPE_S900)&&(tmpfile.osver!=0) /* compressed file in S900 volume? */
+			&&(osver==0)){ /* and supplied/determined osver is incompatible? */
+				/* update uncompr value */
+				akai_s900comprfile_updateuncompr(&tmpfile); /* ignore error */
+		}
+#if 1
+		/* fix name in header (if necessary) */
+		akai_fixramname(&tmpfile); /* ignore error */
+#endif
+	}
+
+tar_import_done:
+	restore_curdir();
+	return ret;
+}
+
+
+
+/* EOF */
diff --git a/third_party/akaiutil/akaiutil_tar.h b/third_party/akaiutil/akaiutil_tar.h
new file mode 100755
index 0000000..f2717c6
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_tar.h
@@ -0,0 +1,95 @@
+#ifndef __AKAIUTIL_TAR_H
+#define __AKAIUTIL_TAR_H
+/*
+* Copyright (C) 2008,2010,2012,2019,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+
+
+
+/* tar header */
+
+/* Note: numbers in octal, trailing '\0' */
+struct tar_head_s{
+#define TAR_NAMELEN 100 /* incl. '\0' */
+	char name[TAR_NAMELEN];
+	char mode[8];
+	char uid[8];
+	char gid[8];
+	char size[12];
+	char mtime[12];
+	char chksum[7];
+	char space;
+	char type;
+	char linkname[TAR_NAMELEN];
+#define TAR_USTAR "ustar\00000"
+	char ustar[8];
+	char uname[32];
+	char gname[32];
+	char devmajor[8];
+	char devminor[8];
+#define TAR_PREFIXLEN 155 /* incl. '\0' */
+	char prefix[TAR_PREFIXLEN];
+	char zero[12];
+};
+/* should be 512 bytes */
+#define TAR_BLOCKSIZE 512 /* in bytes */
+
+#define TAR_TYPE_REG  '0'  /* regular file */
+#define TAR_TYPE_REG0 '\0' /* regular file */
+#define TAR_TYPE_DIR  '5'  /* directory */
+
+#define TAR_TAILZERO_BLOCKS	6 /* number or zero blocks at file end */
+
+
+
+/* Declarations */
+
+extern u_int tar_checksum(u_char *hp);
+
+#define TAR_EXPORT_DISK				0x0001
+#define TAR_EXPORT_PART				0x0002
+#define TAR_EXPORT_VOL				0x0004
+#define TAR_EXPORT_FILE				0x0008
+#define TAR_EXPORT_DDFILE			0x0010
+#define TAR_EXPORT_TAGSFILE			0x0020
+#define TAR_EXPORT_VOLPARAMFILE		0x0040
+#define TAR_EXPORT_ANYFILE			(TAR_EXPORT_FILE|TAR_EXPORT_DDFILE|TAR_EXPORT_TAGSFILE|TAR_EXPORT_VOLPARAMFILE)
+#define TAR_EXPORT_WAV				0x1000
+extern int tar_export(int fd,struct disk_s *dp,struct part_s *pp,struct vol_s *vp,struct file_s *fp,u_int ti,u_int flags,int verbose,u_char *filtertagp);
+extern int tar_export_vol(int fd,struct vol_s *vp,u_int flags,int verbose,u_char *filtertagp);
+extern int tar_export_part(int fd,struct part_s *pp,u_int flags,int verbose,u_char *filtertagp);
+extern int tar_export_disk(int fd,struct disk_s *dp,u_int flags,int verbose,u_char *filtertagp);
+extern int tar_export_alldisks(int fd,u_int flags,int verbose,u_char *filtertagp);
+extern int tar_export_curdir(int fd,int verbose,u_int flags);
+extern int tar_export_tailzero(int fd);
+
+#define TAR_IMPORT_WAV				0x0100
+#define TAR_IMPORT_WAVS9			0x1000
+#define TAR_IMPORT_WAVS9C			0x2000
+#define TAR_IMPORT_WAVS1			0x4000
+#define TAR_IMPORT_WAVS3			0x8000
+extern int tar_import_curdir(int fd,u_int vtype0,int verbose,u_int flags);
+
+
+
+#endif /* !__AKAIUTIL_TAR_H */
diff --git a/third_party/akaiutil/akaiutil_wav.c b/third_party/akaiutil/akaiutil_wav.c
new file mode 100755
index 0000000..8a03f62
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_wav.c
@@ -0,0 +1,482 @@
+/*
+* Copyright (C) 2010,2019 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+#include "akaiutil_wav.h"
+
+
+
+int
+wav_write_head(int outdes,
+			   u_int datasize,u_int chnr,u_int samprate,u_int bitnr,
+			   u_int extrasize)
+{
+	struct wav_riffhead_s wavriffhead;
+	struct wav_chunkhead_s wavchunkhead;
+	struct wav_fmthead_s wavfmthead;
+	u_int drate;
+
+	/* create WAVE RIFF header */
+	bzero(&wavriffhead,sizeof(struct wav_riffhead_s));
+	bcopy(WAV_RIFFHEAD_RIFFSTR,wavriffhead.riffstr,4);
+	{
+		u_int fsize;
+
+		fsize=WAV_HEAD_SIZE-sizeof(struct wav_chunkhead_s)+datasize+extrasize;
+		wavriffhead.fsize[0]=0xff&fsize;
+		wavriffhead.fsize[1]=0xff&(fsize>>8);
+		wavriffhead.fsize[2]=0xff&(fsize>>16);
+		wavriffhead.fsize[3]=0xff&(fsize>>24);
+	}
+	bcopy(WAV_RIFFHEAD_WAVESTR,wavriffhead.wavestr,4);
+
+	/* write WAVE RIFF header */
+	if (WRITE(outdes,&wavriffhead,sizeof(struct wav_riffhead_s))!=sizeof(struct wav_riffhead_s)){
+		PRINTF_ERR("cannot write WAVE RIFF header\n");
+		return -1;
+	}
+
+	/* create FMT chunk header */
+	bcopy(WAV_CHUNKHEAD_FMTSTR,wavchunkhead.typestr,4);
+	{
+		u_int csize;
+
+		csize=sizeof(struct wav_fmthead_s);
+		wavchunkhead.csize[0]=0xff&csize;
+		wavchunkhead.csize[1]=0xff&(csize>>8);
+		wavchunkhead.csize[2]=0xff&(csize>>16);
+		wavchunkhead.csize[3]=0xff&(csize>>24);
+	}
+	/* write chunk header */
+	if (WRITE(outdes,&wavchunkhead,sizeof(struct wav_chunkhead_s))!=sizeof(struct wav_chunkhead_s)){
+		PRINTF_ERR("cannot write WAVE FMT header\n");
+		return -1;
+	}
+
+	/* set FMT header */
+	wavfmthead.ftag[0]=0xff&WAV_HEAD_FTAG_PCM;
+	wavfmthead.ftag[1]=0xff&(WAV_HEAD_FTAG_PCM>>8);
+	wavfmthead.chnr[0]=0xff&chnr;
+	wavfmthead.chnr[1]=0xff&(chnr>>8);
+	wavfmthead.srate[0]=0xff&samprate;
+	wavfmthead.srate[1]=0xff&(samprate>>8);
+	wavfmthead.srate[2]=0xff&(samprate>>16);
+	wavfmthead.srate[3]=0xff&(samprate>>24);
+	drate=chnr*samprate*(bitnr/8); /* chnr!!! */
+	wavfmthead.drate[0]=0xff&drate;
+	wavfmthead.drate[1]=0xff&(drate>>8);
+	wavfmthead.drate[2]=0xff&(drate>>16);
+	wavfmthead.drate[3]=0xff&(drate>>24);
+	wavfmthead.balign[0]=0xff&((bitnr/8)*chnr);      /* chnr!!! */
+	wavfmthead.balign[1]=0xff&(((bitnr/8)*chnr)>>8); /* chnr!!! */
+	wavfmthead.bitnr[0]=0xff&bitnr;
+	wavfmthead.bitnr[1]=0xff&(bitnr>>8);
+
+	/* write WAVE FMT header */
+	if (WRITE(outdes,&wavfmthead,sizeof(struct wav_fmthead_s))!=sizeof(struct wav_fmthead_s)){
+		PRINTF_ERR("cannot write WAVE FMT header\n");
+		return -1;
+	}
+
+	/* create WAVE DATA chunk header */
+	bcopy(WAV_CHUNKHEAD_DATASTR,wavchunkhead.typestr,4);
+	wavchunkhead.csize[0]=0xff&datasize;
+	wavchunkhead.csize[1]=0xff&(datasize>>8);
+	wavchunkhead.csize[2]=0xff&(datasize>>16);
+	wavchunkhead.csize[3]=0xff&(datasize>>24);
+
+	/* write chunk header */
+	if (WRITE(outdes,&wavchunkhead,sizeof(struct wav_chunkhead_s))!=sizeof(struct wav_chunkhead_s)){
+		PRINTF_ERR("cannot write WAVE DATA header\n");
+		return -1;
+	}
+
+	return 0;
+}
+
+
+
+int
+wav_read_head(int indes,
+			  u_int *bcountp,
+			  u_int *datasizep,u_int *chnrp,u_int *sampratep,u_int *bitnrp,
+			  u_int *extrasizep,
+			  char **errstrp)
+{
+	struct wav_riffhead_s wavriffhead;
+	struct wav_chunkhead_s wavchunkhead;
+	struct wav_fmthead_s wavfmthead;
+	u_int i;
+	u_int bcount;
+	u_int remain;
+	u_int csize;
+	u_int chnr;
+	u_int samprate;
+	u_int bitnr;
+
+	bcount=0; /* no bytes read yet */
+
+	/* read WAVE RIFF header */
+	if (READ(indes,(char *)&wavriffhead,sizeof(struct wav_riffhead_s))!=sizeof(struct wav_riffhead_s)){
+		if (errstrp!=NULL){
+			*errstrp="read WAVE RIFF header";
+		}
+		return -1;
+	}
+	bcount+=sizeof(struct wav_riffhead_s);
+
+	/* check riffstr */
+	for (i=0;i<4;i++){
+		if (WAV_RIFFHEAD_RIFFSTR[i]!=wavriffhead.riffstr[i]){
+			if (errstrp!=NULL){
+				*errstrp="no RIFF";
+			}
+			return -1;
+		}
+	}
+
+	/* determine remaining file size */
+	remain=wavriffhead.fsize[0]
+		+(wavriffhead.fsize[1]<<8)
+		+(wavriffhead.fsize[2]<<16)
+		+(wavriffhead.fsize[3]<<24);
+	if (remain<sizeof(struct wav_riffhead_s)-sizeof(struct wav_chunkhead_s)){
+		if (errstrp!=NULL){
+			*errstrp="invalid file size";
+		}
+		return -1;
+	}
+	remain-=sizeof(struct wav_riffhead_s)-sizeof(struct wav_chunkhead_s);
+
+	/* check wavestr */
+	for (i=0;i<4;i++){
+		if (WAV_RIFFHEAD_WAVESTR[i]!=wavriffhead.wavestr[i]){
+			if (errstrp!=NULL){
+				*errstrp="no WAVE";
+			}
+			return -1;
+		}
+	}
+
+	/* search for fmt chunk */
+	for (;;){
+		/* read next chunk */
+		if (remain<sizeof(struct wav_chunkhead_s)){
+			if (errstrp!=NULL){
+				*errstrp="invalid file size";
+			}
+			return -1;
+		}
+		if (READ(indes,(char *)&wavchunkhead,sizeof(struct wav_chunkhead_s))!=sizeof(struct wav_chunkhead_s)){
+			if (errstrp!=NULL){
+				*errstrp="read WAVE FMT header";
+			}
+			return -1;
+		}
+		bcount+=sizeof(struct wav_chunkhead_s);
+		remain-=sizeof(struct wav_chunkhead_s);
+
+		/* get csize */
+		csize=wavchunkhead.csize[0]
+			+(wavchunkhead.csize[1]<<8)
+			+(wavchunkhead.csize[2]<<16)
+			+(wavchunkhead.csize[3]<<24);
+		if (remain<csize){
+			if (errstrp!=NULL){
+				*errstrp="invalid file size";
+			}
+			return -1;
+		}
+
+		for (i=0;i<4;i++){
+			if (WAV_CHUNKHEAD_FMTSTR[i]!=wavchunkhead.typestr[i]){
+				break; /* not fmt chunk */
+			}
+		}
+		if (i==4){
+			break; /* found fmt */
+		}
+
+		/* skip rest of chunk */
+		if (LSEEK64(indes,(OFF64_T)csize,SEEK_CUR)<0){
+			if (errstrp!=NULL){
+				*errstrp="lseek WAVE FMT header";
+			}
+			return -1;
+		}
+		bcount+=csize;
+		remain-=csize;
+	}
+	if (csize!=sizeof(struct wav_fmthead_s)){
+		if (errstrp!=NULL){
+			*errstrp="invalid FMT csize";
+		}
+		return -1;
+	}
+
+	/* read rest of fmt chunk */
+	if (READ(indes,(char *)&wavfmthead,sizeof(struct wav_fmthead_s))!=sizeof(struct wav_fmthead_s)){
+		if (errstrp!=NULL){
+			*errstrp="read WAVE FMT header";
+		}
+		return -1;
+	}
+	bcount+=sizeof(struct wav_fmthead_s);
+	remain-=sizeof(struct wav_fmthead_s);
+
+	/* check ftag */
+	/* XXX allow only PCM */
+	if ((wavfmthead.ftag[0]!=(0xff&WAV_HEAD_FTAG_PCM))
+		||(wavfmthead.ftag[1]!=(0xff&(WAV_HEAD_FTAG_PCM>>8)))){
+		if (errstrp!=NULL){
+			*errstrp="invalid ftag, must be PCM format";
+		}
+		return -1;
+	}
+
+	/* get chnr */
+	chnr=wavfmthead.chnr[0]
+		+(wavfmthead.chnr[1]<<8);
+	if (chnr==0){
+		if (errstrp!=NULL){
+			*errstrp="invalid chnr";
+		}
+		return -1;
+	}
+
+	/* set samprate */
+	samprate=wavfmthead.srate[0]
+		+(wavfmthead.srate[1]<<8)
+		+(wavfmthead.srate[2]<<16)
+		+(wavfmthead.srate[3]<<24);
+
+	/* XXX check drate: must be chnr*samprate*(bitnr/8) */
+
+	/* get bitnr */
+	bitnr=wavfmthead.bitnr[0]
+		+(wavfmthead.bitnr[1]<<8);
+	if (bitnr==0){
+		if (errstrp!=NULL){
+			*errstrp="invalid bitnr";
+		}
+		return -1;
+	}
+
+	/* XXX check balign: must be (bitnr/8)*chnr */
+
+	/* search for data chunk */
+	for (;;){
+		/* read next chunk */
+		if (remain<sizeof(struct wav_chunkhead_s)){
+			if (errstrp!=NULL){
+				*errstrp="invalid file size";
+			}
+			return -1;
+		}
+		if (READ(indes,(char *)&wavchunkhead,sizeof(struct wav_chunkhead_s))!=sizeof(struct wav_chunkhead_s)){
+			if (errstrp!=NULL){
+				*errstrp="read WAVE DATA header";
+			}
+			return -1;
+		}
+		bcount+=sizeof(struct wav_chunkhead_s);
+		remain-=sizeof(struct wav_chunkhead_s);
+
+		/* get csize */
+		csize=wavchunkhead.csize[0]
+			+(wavchunkhead.csize[1]<<8)
+			+(wavchunkhead.csize[2]<<16)
+			+(wavchunkhead.csize[3]<<24);
+		if (remain<csize){
+			if (errstrp!=NULL){
+				*errstrp="invalid file size";
+			}
+			return -1;
+		}
+
+		for (i=0;i<4;i++){
+			if (WAV_CHUNKHEAD_DATASTR[i]!=wavchunkhead.typestr[i]){
+				break; /* not data chunk */
+			}
+		}
+		if (i==4){
+			break; /* found fmt */
+		}
+
+		/* skip rest of chunk */
+		if (LSEEK64(indes,(OFF64_T)csize,SEEK_CUR)<0){
+			if (errstrp!=NULL){
+				*errstrp="lseek WAVE DATA header";
+			}
+			return -1;
+		}
+		bcount+=csize;
+		remain-=csize;
+	}
+	if (csize%chnr!=0){
+		if (errstrp!=NULL){
+			*errstrp="invalid DATA csize";
+		}
+		return -1;
+	}
+
+	if (bcountp!=NULL){
+		*bcountp=bcount;
+	}
+	if (datasizep!=NULL){
+		*datasizep=csize;
+	}
+	if (chnrp!=NULL){
+		*chnrp=chnr;
+	}
+	if (sampratep!=NULL){
+		*sampratep=samprate;
+	}
+	if (bitnrp!=NULL){
+		*bitnrp=bitnr;
+	}
+	if (extrasizep!=NULL){
+		*extrasizep=remain-csize;
+	}
+	
+	return 0;
+}
+
+
+
+#ifndef WAV_AKAIHEAD_DISABLE
+int
+wav_find_akaihead(int indes,u_int *bcountp,u_int *csizep,u_int remain,u_int searchtype)
+{
+	struct wav_chunkhead_s wavchunkhead;
+	u_int bcount;
+	u_int csize;
+	u_int type;
+	u_int i;
+
+	bcount=0; /* no bytes read yet */
+	csize=0; /* no chunk yet */
+	type=WAV_AKAIHEADTYPE_NONE; /* no AKAI header chunk found yet */
+
+	/* search for AKAI header chunk */
+	for (;;){
+		/* read next chunk */
+		if (remain<sizeof(struct wav_chunkhead_s)){
+			break;
+		}
+		if (READ(indes,(char *)&wavchunkhead,sizeof(struct wav_chunkhead_s))<0){
+			PRINTF_ERR("cannot read WAV chunk");
+			return -1;
+		}
+		bcount+=sizeof(struct wav_chunkhead_s);
+		remain-=sizeof(struct wav_chunkhead_s);
+
+		/* get csize */
+		csize=wavchunkhead.csize[0]
+			+(wavchunkhead.csize[1]<<8)
+			+(wavchunkhead.csize[2]<<16)
+			+(wavchunkhead.csize[3]<<24);
+		if (remain<csize){
+			break;
+		}
+
+		if ((searchtype==WAV_AKAIHEADTYPE_NONE)||(searchtype==WAV_AKAIHEADTYPE_SAMPLE900)){
+			/* check if S900 sample header chunk */
+			for (i=0;i<4;i++){
+				if (WAV_CHUNKHEAD_AKAIS900SAMPLEHEADSTR[i]!=wavchunkhead.typestr[i]){
+					break; /* not data chunk */
+				}
+			}
+			if (i==4){
+				/* found */
+				type=WAV_AKAIHEADTYPE_SAMPLE900;
+				break;
+			}
+		}
+
+		if ((searchtype==WAV_AKAIHEADTYPE_NONE)||(searchtype==WAV_AKAIHEADTYPE_SAMPLE1000)){
+			/* check if S1000 sample header chunk */
+			for (i=0;i<4;i++){
+				if (WAV_CHUNKHEAD_AKAIS1000SAMPLEHEADSTR[i]!=wavchunkhead.typestr[i]){
+					break; /* not data chunk */
+				}
+			}
+			if (i==4){
+				/* found */
+				type=WAV_AKAIHEADTYPE_SAMPLE1000;
+				break;
+			}
+		}
+
+		if ((searchtype==WAV_AKAIHEADTYPE_NONE)||(searchtype==WAV_AKAIHEADTYPE_SAMPLE3000)){
+			/* check if S3000 sample header chunk */
+			for (i=0;i<4;i++){
+				if (WAV_CHUNKHEAD_AKAIS3000SAMPLEHEADSTR[i]!=wavchunkhead.typestr[i]){
+					break; /* not data chunk */
+				}
+			}
+			if (i==4){
+				/* found */
+				type=WAV_AKAIHEADTYPE_SAMPLE3000;
+				break;
+			}
+		}
+
+		if ((searchtype==WAV_AKAIHEADTYPE_NONE)||(searchtype==WAV_AKAIHEADTYPE_DDTAKE)){
+			/* check if DD take header chunk */
+			for (i=0;i<4;i++){
+				if (WAV_CHUNKHEAD_AKAIDDTAKEHEADSTR[i]!=wavchunkhead.typestr[i]){
+					break; /* not data chunk */
+				}
+			}
+			if (i==4){
+				/* found */
+				type=WAV_AKAIHEADTYPE_DDTAKE;
+				break;
+			}
+		}
+
+		/* skip rest of chunk */
+		if (LSEEK64(indes,(OFF64_T)csize,SEEK_CUR)<0){
+			PERROR("cannot lseek WAV chunk");
+			return -1;
+		}
+		bcount+=csize;
+		remain-=csize;
+	}
+	if (type==WAV_AKAIHEADTYPE_NONE){ /* no AKAI header chunk found? */
+		csize=0;
+	}
+
+	if (bcountp!=NULL){
+		*bcountp=bcount;
+	}
+	if (csizep!=NULL){
+		*csizep=csize;
+	}
+	return (int)type;
+}
+#endif
+
+
+
+/* EOF */
diff --git a/third_party/akaiutil/akaiutil_wav.h b/third_party/akaiutil/akaiutil_wav.h
new file mode 100755
index 0000000..e3c4858
--- /dev/null
+++ b/third_party/akaiutil/akaiutil_wav.h
@@ -0,0 +1,99 @@
+#ifndef __AKAIUTIL_WAV_H
+#define __AKAIUTIL_WAV_H
+/*
+* Copyright (C) 2010,2019 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+
+
+
+/* RIFF WAVE format header */
+/* Note: WAV-file is little-endian!!! */
+
+struct wav_riffhead_s{
+/* begin RIFFWAVEChunk */
+#define WAV_RIFFHEAD_RIFFSTR "RIFF"
+	char riffstr[4];   /* must be "RIFF" */
+	u_char fsize[4];   /* following file-size in Bytes */
+#define WAV_RIFFHEAD_WAVESTR "WAVE"
+	char wavestr[4];   /* must be "WAVE" */
+/* end RIFFWAVEChunk */
+};
+
+struct wav_chunkhead_s{
+	char typestr[4];   /* chunk type */
+	u_char csize[4];   /* following chunk-size in Bytes */
+};
+#define WAV_CHUNKHEAD_FMTSTR	"fmt "
+#define WAV_CHUNKHEAD_DATASTR	"data"
+
+struct wav_fmthead_s{
+/* continued FormatChunk */
+#define WAV_HEAD_FTAG_PCM 0x0001 /* 1: PCM/umcompressed */
+	u_char ftag[2];    /* format tag */
+	u_char chnr[2];    /* number of channels */
+	u_char srate[4];   /* sample rate in samples/sec */
+	u_char drate[4];   /* total data rate in Bytes/sec */
+	u_char balign[2];  /* number of Bytes per sample * chnr */
+	u_char bitnr[2];   /* number of Bits per sample */
+/* end FormatChunk */
+};
+
+
+
+#define WAV_HEAD_SIZE	(sizeof(struct wav_riffhead_s)+sizeof(struct wav_chunkhead_s)+sizeof(struct wav_fmthead_s)+sizeof(struct wav_chunkhead_s))
+
+
+
+#ifndef WAV_AKAIHEAD_DISABLE
+/* AKAI header chunks */
+#define WAV_CHUNKHEAD_AKAIS900SAMPLEHEADSTR		"S9H "
+#define WAV_CHUNKHEAD_AKAIS1000SAMPLEHEADSTR	"S1H "
+#define WAV_CHUNKHEAD_AKAIS3000SAMPLEHEADSTR	"S3H "
+#define WAV_CHUNKHEAD_AKAIDDTAKEHEADSTR			"TKH "
+#endif
+
+
+
+/* Declarations */
+
+extern int wav_write_head(int outdes,
+						  u_int datasize,u_int chnr,u_int samprate,u_int bitnr,
+						  u_int extrasize);
+
+extern int wav_read_head(int indes,u_int *bcountp,
+						 u_int *datasizep,u_int *chnrp,u_int *sampratep,u_int *bitnrp,
+						 u_int *extrasizep,
+						 char **errstrp);
+
+#ifndef WAV_AKAIHEAD_DISABLE
+#define WAV_AKAIHEADTYPE_NONE			0x00
+#define WAV_AKAIHEADTYPE_SAMPLE900		0x09
+#define WAV_AKAIHEADTYPE_SAMPLE1000		0x01
+#define WAV_AKAIHEADTYPE_SAMPLE3000		0x03
+#define WAV_AKAIHEADTYPE_DDTAKE			0xdd
+int wav_find_akaihead(int indes,u_int *bcountp,u_int *csizep,u_int remain,u_int searchtype);
+#endif
+
+
+
+#endif /* !__AKAIUTIL_WAV_H */
diff --git a/third_party/akaiutil/commoninclude.h b/third_party/akaiutil/commoninclude.h
new file mode 100755
index 0000000..f0ad174
--- /dev/null
+++ b/third_party/akaiutil/commoninclude.h
@@ -0,0 +1,237 @@
+#ifndef __COMMONINCLUDE_H
+#define __COMMONINCLUDE_H
+/*
+* Copyright (C) 2008,2010,2012,2019,2020,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#ifdef _VISUALCPP
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <Windows.h>
+#include <io.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <limits.h>
+/*#include <unistd.h>*/
+/*#include <strings.h>*/
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+
+typedef unsigned char u_char;
+typedef unsigned int u_int;
+typedef unsigned long u_long;
+typedef int ssize_t;
+#ifndef SSIZE_MAX
+#define SSIZE_MAX INT_MAX
+#endif /* !SSIZE_MAX */
+
+#define INT64 __int64
+#define U_INT64 unsigned __int64
+#define OFF_T __int64
+#define OFF64_T __int64
+
+#define OPEN _open
+#define CLOSE _close
+#define READ _read
+#define WRITE _write
+/* default lseek and off_t cannot handle offsets>=2GB! */
+#define LSEEK _lseeki64
+#define LSEEK64 _lseeki64
+
+extern int strcasecmp(const char *s1,const char *s2);
+extern int strncasecmp(const char *s1,const char *s2,size_t n);
+
+/* getopt */
+/*#include <unistd.h>*/
+extern int getopt(int argc,char * const argv[],const char *optstring);
+extern char *optarg;
+extern int optind;
+extern int opterr;
+extern int optopt;
+
+/* Note: returned value of _snprintf_s() can differ from returned value of snprintf() */
+#define SNPRINTF(x,y,...)	_snprintf_s((x),(y),_TRUNCATE,__VA_ARGS__)
+
+/* XXX ignore returned value */
+#define SYSTEM(x)	{system(x);}
+
+/* local (external) filesystem */
+#include <direct.h>
+#define LCHDIR(d)			_chdir(d)
+#define LDIR				SYSTEM("dir")
+#define LDELFILE(x,y,n)		{_snprintf_s((x),(y),_TRUNCATE,"del /q /f \"%s\"",(n)); SYSTEM(x);}
+
+/* play external WAV file */
+#define PLAYWAV_PREPARE(x,y,n)	SNPRINTF((x),(y),"%s",(n))
+#define PLAYWAV_START(x)		PlaySoundA((LPCSTR)(x),NULL,SND_ASYNC|SND_FILENAME|SND_NODEFAULT)
+#define PLAYWAV_STOP			PlaySoundA(NULL,NULL,0)
+
+
+
+#else /* !_VISUALCPP */
+/* e.g. UNIX-like systems or cygwin */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <limits.h>
+#include <unistd.h>
+#include <strings.h>
+#include <string.h>
+#include <ctype.h>
+#include <time.h>
+
+#define INT64 __int64_t
+#define U_INT64 __uint64_t
+#define OFF_T off_t
+#define OFF64_T int64_t
+
+#ifndef NOT_MYLSEEK64
+/* own 64bit version of lseek */
+extern OFF64_T mylseek64(int filedes,OFF64_T offset,int whence);
+#define LSEEK64	mylseek64
+#endif
+
+#ifndef __CYGWIN__
+/* e.g. UNIX-like systems */
+/* getopt */
+#include <unistd.h>
+extern int getopt(int argc,char * const argv[],const char *optstring);
+extern char *optarg;
+extern int optind;
+extern int opterr;
+extern int optopt;
+#endif /* !__CYGWIN__*/
+
+#define SNPRINTF(x,y,...)	snprintf((x),(y),__VA_ARGS__)
+
+/* XXX ignore returned value */
+#define SYSTEM(x)	{if (system(x)<0){;}}
+
+/* local (external) filesystem */
+#include <dirent.h>
+#define LCHDIR(d)			chdir(d)
+#define LDIR				SYSTEM("ls -la")
+#define LDELFILE(x,y,n)		{SNPRINTF((x),(y),"rm -f \"%s\"",(n)); SYSTEM(x);}
+
+/* play external WAV file */
+#ifndef PLAYWAV_CMD
+#ifdef __APPLE__
+#define PLAYWAV_CMD		"afplay"
+#else /* !__APPLE__ */
+/* use PulseAudio */
+#define PLAYWAV_CMD		"paplay"
+#endif /* !__APPLE__ */
+#endif /* !PLAYWAV_CMD */
+#define PLAYWAV_PREPARE(x,y,n)	snprintf((x),(y),PLAYWAV_CMD " \"%s\" > /dev/null 2>&1 &",(n))
+#define PLAYWAV_START(x)		SYSTEM((const char *)(x))
+#define PLAYWAV_STOP			SYSTEM("killall " PLAYWAV_CMD " > /dev/null 2>&1")
+
+
+
+#endif /* !_VISUALCPP */
+
+
+
+#include <math.h>
+
+/* O_BINARY important for Windows-based systems (esp. cygwin or VC++) */
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif /* !O_BINARY */
+#ifndef OPEN
+#define OPEN open
+#endif
+#ifndef CLOSE
+#define CLOSE close
+#endif
+#ifndef READ
+#define READ read
+#endif
+#ifndef WRITE
+#define WRITE write
+#endif
+#ifndef LSEEK
+#define LSEEK lseek
+#endif
+#ifndef LSEEK64
+#define LSEEK64 lseek64
+#endif
+
+extern void bcopy(const void *src,void *dst,size_t len);
+extern void bzero(void *b,size_t len);
+
+
+
+#ifndef STRHEX_TO_UINT64
+extern U_INT64 my_strhex_to_uint64(char *s);
+#define STRHEX_TO_UINT64	my_strhex_to_uint64
+#define USE_MY_STRHEX_TO_UINT64
+#endif
+#ifndef STRDEC_TO_UINT64
+extern U_INT64 my_strdec_to_uint64(char *s);
+#define STRDEC_TO_UINT64	my_strdec_to_uint64
+#define USE_MY_STRDEC_TO_UINT64
+#endif
+
+
+
+#ifdef UI_INCLUDE
+/* external user interface */
+#include UI_INCLUDE
+#endif
+
+
+
+/* console I/O */
+
+#ifndef FGETS
+#define FGETS				fgets
+#endif
+#ifndef PRINTF_OUT
+#define PRINTF_OUT(...)		fprintf(stdout,__VA_ARGS__)
+#endif
+#ifndef FLUSH_OUT
+#define FLUSH_OUT			fflush(stdout)
+#endif
+#ifndef PRINTF_ERR
+#define PRINTF_ERR(...)		fprintf(stderr,__VA_ARGS__)
+#endif
+#ifndef PERROR
+#include <errno.h>
+#define PERROR(x)			PRINTF_ERR("%s: %s\n",x,strerror(errno))
+#endif
+#ifndef FLUSH_ALL
+#define FLUSH_ALL			fflush(NULL)
+#endif
+
+
+
+#endif /* !__COMMONINCLUDE_H */
diff --git a/third_party/akaiutil/commonlib.c b/third_party/akaiutil/commonlib.c
new file mode 100755
index 0000000..1d8266a
--- /dev/null
+++ b/third_party/akaiutil/commonlib.c
@@ -0,0 +1,454 @@
+/*
+* unless noted otherwise: Copyright (C) 2003-2010,2019,2020,2021 Klaus Michael Indlekofer. All rights reserved.
+*
+* m.indlekofer@gmx.de
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version 2
+* of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+
+
+#include "commoninclude.h"
+
+
+
+#ifdef _VISUALCPP
+
+
+
+/* bcopy, bzero */
+/* (c) 2003, 2004 by K. M. Indlekofer */
+void
+bcopy(const void *src,void *dst,size_t len)
+{
+	char *cp1,*cp2;
+	
+	cp1=(char *)src;
+	cp2=(char *)dst;
+	/* XXX no check for NULL pointer */
+	while (len-->0){
+		*cp2=*cp1;
+		cp1++;
+		cp2++;
+	}
+}
+
+void
+bzero(void *b,size_t len)
+{
+	char *cp;
+	
+	cp=(char *)b;
+	/* XXX no check for NULL pointer */
+	while (len-->0){
+		*cp=0;
+		cp++;
+	}
+}
+
+
+
+/* strcasecmp */
+/*
+* Copyright (c) 1987, 1993
+*    The Regents of the University of California.  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions
+* are met:
+* 1. Redistributions of source code must retain the above copyright
+*    notice, this list of conditions and the following disclaimer.
+* 2. Redistributions in binary form must reproduce the above copyright
+*    notice, this list of conditions and the following disclaimer in the
+*    documentation and/or other materials provided with the distribution.
+* 3. All advertising materials mentioning features or use of this software
+*    must display the following acknowledgement:
+* 	This product includes software developed by the University of
+* 	California, Berkeley and its contributors.
+* 4. Neither the name of the University nor the names of its contributors
+*    may be used to endorse or promote products derived from this software
+*    without specific prior written permission.
+* 
+* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+* SUCH DAMAGE.
+*/
+
+/*
+* This array is designed for mapping upper and lower case letter
+* together for a case independent comparison.  The mappings are
+* based upon ascii character sequences.
+*/
+static const u_char charmap[] = {
+	0000, 0001, 0002, 0003, 0004, 0005, 0006, 0007,
+		0010, 0011, 0012, 0013, 0014, 0015, 0016, 0017,
+		0020, 0021, 0022, 0023, 0024, 0025, 0026, 0027,
+		0030, 0031, 0032, 0033, 0034, 0035, 0036, 0037,
+		0040, 0041, 0042, 0043, 0044, 0045, 0046, 0047,
+		0050, 0051, 0052, 0053, 0054, 0055, 0056, 0057,
+		0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
+		0070, 0071, 0072, 0073, 0074, 0075, 0076, 0077,
+		0100, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
+		0150, 0151, 0152, 0153, 0154, 0155, 0156, 0157,
+		0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167,
+		0170, 0171, 0172, 0133, 0134, 0135, 0136, 0137,
+		0140, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
+		0150, 0151, 0152, 0153, 0154, 0155, 0156, 0157,
+		0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167,
+		0170, 0171, 0172, 0173, 0174, 0175, 0176, 0177,
+		0200, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
+		0210, 0211, 0212, 0213, 0214, 0215, 0216, 0217,
+		0220, 0221, 0222, 0223, 0224, 0225, 0226, 0227,
+		0230, 0231, 0232, 0233, 0234, 0235, 0236, 0237,
+		0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247,
+		0250, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
+		0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
+		0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
+		0300, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
+		0310, 0311, 0312, 0313, 0314, 0315, 0316, 0317,
+		0320, 0321, 0322, 0323, 0324, 0325, 0326, 0327,
+		0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
+		0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
+		0350, 0351, 0352, 0353, 0354, 0355, 0356, 0357,
+		0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
+		0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377
+};
+
+int
+strcasecmp(const char *s1, const char *s2) {
+	const u_char *cm = charmap,
+		*us1 = (const u_char *)s1,
+		*us2 = (const u_char *)s2;
+	
+	while (cm[*us1] == cm[*us2++])
+		if (*us1++ == '\0')
+			return (0);
+		return (cm[*us1] - cm[*--us2]);
+}
+
+int
+strncasecmp(const char *s1, const char *s2, size_t n) {
+	if (n != 0) {
+		const u_char *cm = charmap,
+			*us1 = (const u_char *)s1,
+			*us2 = (const u_char *)s2;
+		
+		do {
+			if (cm[*us1] != cm[*us2++])
+				return (cm[*us1] - cm[*--us2]);
+			if (*us1++ == '\0')
+				break;
+		} while (--n != 0);
+	}
+	return (0);
+}
+
+
+
+/* getopt */
+/*
+* getopt.c --
+*
+*      Standard UNIX getopt function.  Code is from BSD.
+*
+* Copyright (c) 1987-2002 The Regents of the University of California.
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* A. Redistributions of source code must retain the above copyright notice,
+*    this list of conditions and the following disclaimer.
+* B. Redistributions in binary form must reproduce the above copyright notice,
+*    this list of conditions and the following disclaimer in the documentation
+*    and/or other materials provided with the distribution.
+* C. Neither the names of the copyright holders nor the names of its
+*    contributors may be used to endorse or promote products derived from this
+*    software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+* IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
+* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+* POSSIBILITY OF SUCH DAMAGE.
+*/
+/* modified by K.M.Indlekofer */
+
+/* #if !defined(lint)
+* static char sccsid[] = "@(#)getopt.c 8.2 (Berkeley) 4/2/94";
+* #endif
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* declarations to provide consistent linkage */
+extern char *optarg;
+extern int optind;
+extern int opterr;
+
+int     opterr = 1,             /* if error message should be printed */
+optind = 1,             /* index into parent argv vector */
+optopt,                 /* character checked for validity */
+optreset;               /* reset getopt */
+char    *optarg;                /* argument associated with option */
+
+#define BADCH   (int)'?'
+#define BADARG  (int)':'
+#define EMSG    ""
+
+								/*
+								* getopt --
+								*      Parse argc/argv argument vector.
+*/
+int
+getopt(nargc, nargv, ostr)
+int nargc;
+char * const *nargv;
+const char *ostr;
+{
+	static char *place = EMSG;              /* option letter processing */
+	char *oli;                              /* option letter list index */
+	
+	if (optreset || !*place) {              /* update scanning pointer */
+		optreset = 0;
+		if (optind >= nargc || *(place = nargv[optind]) != '-') {
+			place = EMSG;
+			return (EOF);
+		}
+		if (place[1] && *++place == '-') {      /* found "--" */
+			++optind;
+			place = EMSG;
+			return (EOF);
+		}
+	}                                       /* option letter okay? */
+	if ((optopt = (int)*place++) == (int)':' ||
+		!(oli = strchr(ostr, optopt))) {
+		/*
+		* if the user didn't specify '-' as an option,
+		* assume it means EOF.
+		*/
+		if (optopt == (int)'-')
+			return (EOF);
+		if (!*place)
+			++optind;
+#ifdef GETOPT_PRINTF_ERR
+		if (opterr && *ostr != ':')
+			(void)GETOPT_PRINTF_ERR(
+			"%s: illegal option -- %c\n", __FILE__, optopt);
+#endif
+		return (BADCH);
+	}
+	if (*++oli != ':') {                    /* don't need argument */
+		optarg = NULL;
+		if (!*place)
+			++optind;
+	}
+	else {                                  /* need an argument */
+		if (*place)                     /* no white space */
+			optarg = place;
+		else if (nargc <= ++optind) {   /* no arg */
+			place = EMSG;
+			if (*ostr == ':')
+				return (BADARG);
+#ifdef GETOPT_PRINTF_ERR
+			if (opterr)
+				(void)GETOPT_PRINTF_ERR(
+				"%s: option requires an argument -- %c\n",
+				__FILE__, optopt);
+#endif
+			return (BADCH);
+		}
+		else                            /* white space */
+			optarg = nargv[optind];
+		place = EMSG;
+		++optind;
+	}
+	return (optopt);                        /* dump back option letter */
+}
+
+
+
+#else /* !_VISUALCPP */
+/* e.g. UNIX-like systems or cygwin */
+
+
+
+#ifndef NOT_MYLSEEK64
+/* own 64bit version of lseek */
+OFF64_T
+mylseek64(int filedes,OFF64_T offset,int whence)
+{
+	OFF64_T remain;
+	OFF64_T chunk;
+	OFF64_T ret;
+	OFF64_T c;
+	int whence2;
+
+	ret=0;
+	remain=offset;
+	for (c=0;;c++){
+		chunk=remain;
+		if (chunk>0x40000000){ /* XXX */
+			chunk=0x40000000;
+		}else if (chunk<-0x40000000){
+			chunk=-0x40000000;
+		}
+		if ((whence==SEEK_SET)&&(c>0)){ /* SEEK_SET and not first chunk? */
+			whence2=SEEK_CUR;
+		}else{
+			whence2=whence;
+		}
+#if defined(DEBUGIO)&&defined(MYLSEEK64_PRINTF)
+		MYLSEEK64_PRINTF("c:%08x%08x chunk:%08x\n",(u_int)(c>>32),(u_int)c,(u_int)chunk);
+#endif
+		if (LSEEK(filedes,(OFF_T)chunk,whence2)<0){
+			ret=-1;
+			break;
+		}
+		if (remain==0){
+			break;
+		}
+		remain-=chunk;
+	}
+
+	if (ret<0){
+		return ret;
+	}else{
+		return offset-remain;
+	}
+}
+#endif /* !NOT_MYLSEEK64 */
+
+
+
+#endif /* !_VISUALCPP */
+
+
+
+#ifdef USE_MY_STRHEX_TO_UINT64
+U_INT64
+my_strhex_to_uint64(char *s)
+{
+	u_int l;
+	u_int u1,u2;
+	U_INT64 u;
+	static char s2[8+1]; /* XXX max. 8 upper digits */
+
+	if (s==NULL){
+		return 0;
+	}
+
+	l=(u_int)strlen(s);
+	if (l==0){
+		return 0;
+	}
+
+	/* XXX can handle max. 16 digits */
+	if (l>8){
+#if 1
+		sscanf(s+l-8,"%x",&u1); /* lower 8 digits */
+#else
+		u1=strtol(s+l-8,NULL,16); /* lower 8 digits */
+#endif
+		strncpy(s2,
+				s+((l>16)?(l-16):0),
+				(((l-8)<=8)?(l-8):8)); /* XXX max. 8 upper digits */
+		s2[8]='\0';
+#if 1
+		sscanf(s2,"%x",&u2); /* upper digits */
+#else
+		u2=strtol(s2,NULL,16); /* upper digits */
+#endif
+		u=(((U_INT64)u2)<<32)|((U_INT64)u1);
+	}else{
+#if 1
+		sscanf(s,"%x",&u1);
+		u=(U_INT64)u1;
+#else
+		u=(U_INT64)strtol(s,NULL,16);
+#endif
+	}
+
+	return u;
+}
+#endif
+
+#ifdef USE_MY_STRDEC_TO_UINT64
+U_INT64
+my_strdec_to_uint64(char *s)
+{
+	u_int l;
+	u_int u1,u2;
+	U_INT64 u;
+	static char s2[9+1]; /* XXX max. 9 upper digits */
+
+	if (s==NULL){
+		return 0;
+	}
+
+	l=(u_int)strlen(s);
+	if (l==0){
+		return 0;
+	}
+
+	/* XXX can handle max. 18 digits */
+	if (l>9){
+#if 1
+		sscanf(s+l-9,"%u",&u1); /* lower 9 digits */
+#else
+		u1=strtol(s+l-9,NULL,10); /* lower 9 digits */
+#endif
+		strncpy(s2,
+				s+((l>18)?(l-18):0),
+				(((l-9)<=9)?(l-9):9)); /* XXX max. 9 upper digits */
+		s2[9]='\0';
+#if 1
+		sscanf(s2,"%u",&u2); /* upper digits */
+#else
+		u2=strtol(s2,NULL,10); /* upper digits */
+#endif
+		u=((U_INT64)u2)*((U_INT64)1000000000)+((U_INT64)u1);
+	}else{
+#if 1
+		sscanf(s,"%u",&u1);
+		u=(U_INT64)u1;
+#else
+		u=(U_INT64)strtol(s,NULL,10);
+#endif
+	}
+
+	return u;
+}
+#endif
+
+
+
+/* EOF */
diff --git a/third_party/akaiutil/fdrawcmd.h b/third_party/akaiutil/fdrawcmd.h
new file mode 100755
index 0000000..82c8769
--- /dev/null
+++ b/third_party/akaiutil/fdrawcmd.h
@@ -0,0 +1,299 @@
+// fdrawcmd.sys 1.0.1.11
+//
+// Low-level floppy filter, by Simon Owen
+//
+// http://simonowen.com/fdrawcmd/
+
+#ifndef FDRAWCMD_H
+#define FDRAWCMD_H
+
+#ifndef CTL_CODE
+#include <winioctl.h>
+#endif
+
+#define FDRAWCMD_VERSION                0x0100010b      // Compile-time version, for structures and definitions below
+                                                        // Must be checked with run-time driver for compatibility
+
+#define FD_CTL_CODE(i,m)                CTL_CODE(FILE_DEVICE_UNKNOWN, i, m, FILE_READ_DATA|FILE_WRITE_DATA)
+
+                                                                                // If you're not using C/C++, use the IOCTL values below
+#define IOCTL_FDRAWCMD_GET_VERSION      FD_CTL_CODE(0x888, METHOD_BUFFERED)     // 0x0022e220
+
+#define IOCTL_FDCMD_READ_TRACK          FD_CTL_CODE(0x802, METHOD_OUT_DIRECT)   // 0x0022e00a
+#define IOCTL_FDCMD_SPECIFY             FD_CTL_CODE(0x803, METHOD_BUFFERED)     // 0x0022e00c
+#define IOCTL_FDCMD_SENSE_DRIVE_STATUS  FD_CTL_CODE(0x804, METHOD_BUFFERED)     // 0x0022e010
+#define IOCTL_FDCMD_WRITE_DATA          FD_CTL_CODE(0x805, METHOD_IN_DIRECT)    // 0x0022e015
+#define IOCTL_FDCMD_READ_DATA           FD_CTL_CODE(0x806, METHOD_OUT_DIRECT)   // 0x0022e01a
+#define IOCTL_FDCMD_RECALIBRATE         FD_CTL_CODE(0x807, METHOD_BUFFERED)     // 0x0022e01c
+#define IOCTL_FDCMD_SENSE_INT_STATUS    FD_CTL_CODE(0x808, METHOD_BUFFERED)     // 0x0022e020   // added in 1.0.0.22
+#define IOCTL_FDCMD_WRITE_DELETED_DATA  FD_CTL_CODE(0x809, METHOD_IN_DIRECT)    // 0x0022e025
+#define IOCTL_FDCMD_READ_ID             FD_CTL_CODE(0x80a, METHOD_BUFFERED)     // 0x0022e028
+#define IOCTL_FDCMD_READ_DELETED_DATA   FD_CTL_CODE(0x80c, METHOD_OUT_DIRECT)   // 0x0022e032
+#define IOCTL_FDCMD_FORMAT_TRACK        FD_CTL_CODE(0x80d, METHOD_BUFFERED)     // 0x0022e034
+#define IOCTL_FDCMD_DUMPREG             FD_CTL_CODE(0x80e, METHOD_BUFFERED)     // 0x0022e038
+#define IOCTL_FDCMD_SEEK                FD_CTL_CODE(0x80f, METHOD_BUFFERED)     // 0x0022e03c
+#define IOCTL_FDCMD_VERSION             FD_CTL_CODE(0x810, METHOD_BUFFERED)     // 0x0022e040
+#define IOCTL_FDCMD_SCAN_EQUAL          FD_CTL_CODE(0x811, METHOD_IN_DIRECT)    // 0x0022e045   (not implemented yet)
+#define IOCTL_FDCMD_PERPENDICULAR_MODE  FD_CTL_CODE(0x812, METHOD_BUFFERED)     // 0x0022e048
+#define IOCTL_FDCMD_CONFIGURE           FD_CTL_CODE(0x813, METHOD_BUFFERED)     // 0x0022e04c
+#define IOCTL_FDCMD_LOCK                FD_CTL_CODE(0x814, METHOD_BUFFERED)     // 0x0022e050
+#define IOCTL_FDCMD_VERIFY              FD_CTL_CODE(0x816, METHOD_BUFFERED)     // 0x0022e058
+#define IOCTL_FDCMD_POWERDOWN_MODE      FD_CTL_CODE(0x817, METHOD_BUFFERED)     // 0x0022e05c   (not implemented yet)
+#define IOCTL_FDCMD_PART_ID             FD_CTL_CODE(0x818, METHOD_BUFFERED)     // 0x0022e060
+#define IOCTL_FDCMD_SCAN_LOW_OR_EQUAL   FD_CTL_CODE(0x819, METHOD_IN_DIRECT)    // 0x0022e065   (not implemented yet)
+#define IOCTL_FDCMD_SCAN_HIGH_OR_EQUAL  FD_CTL_CODE(0x81d, METHOD_IN_DIRECT)    // 0x0022e075   (not implemented yet)
+#define IOCTL_FDCMD_SAVE                FD_CTL_CODE(0x82e, METHOD_BUFFERED)     // 0x0022e0b8   (not implemented yet)
+#define IOCTL_FDCMD_OPTION              FD_CTL_CODE(0x833, METHOD_BUFFERED)     // 0x0022e0cc   (not implemented yet)
+#define IOCTL_FDCMD_RESTORE             FD_CTL_CODE(0x84e, METHOD_BUFFERED)     // 0x0022e138   (not implemented yet)
+#define IOCTL_FDCMD_DRIVE_SPEC_CMD      FD_CTL_CODE(0x88e, METHOD_BUFFERED)     // 0x0022e238   (not implemented yet)
+#define IOCTL_FDCMD_RELATIVE_SEEK       FD_CTL_CODE(0x88f, METHOD_BUFFERED)     // 0x0022e23c
+#define IOCTL_FDCMD_FORMAT_AND_WRITE    FD_CTL_CODE(0x8ef, METHOD_BUFFERED)     // 0x0022e3bc   // added in 1.0.1.10
+
+#define IOCTL_FD_SCAN_TRACK             FD_CTL_CODE(0x900, METHOD_BUFFERED)     // 0x0022e400
+#define IOCTL_FD_GET_RESULT             FD_CTL_CODE(0x901, METHOD_BUFFERED)     // 0x0022e404
+#define IOCTL_FD_RESET                  FD_CTL_CODE(0x902, METHOD_BUFFERED)     // 0x0022e408
+#define IOCTL_FD_SET_MOTOR_TIMEOUT      FD_CTL_CODE(0x903, METHOD_BUFFERED)     // 0x0022e40c
+#define IOCTL_FD_SET_DATA_RATE          FD_CTL_CODE(0x904, METHOD_BUFFERED)     // 0x0022e410
+#define IOCTL_FD_GET_FDC_INFO           FD_CTL_CODE(0x905, METHOD_BUFFERED)     // 0x0022e414
+#define IOCTL_FD_GET_REMAIN_COUNT       FD_CTL_CODE(0x906, METHOD_BUFFERED)     // 0x0022e418   // added in 1.0.0.22
+#define IOCTL_FD_SET_DISK_CHECK         FD_CTL_CODE(0x908, METHOD_BUFFERED)     // 0x0022e420
+#define IOCTL_FD_SET_SHORT_WRITE        FD_CTL_CODE(0x909, METHOD_BUFFERED)     // 0x0022e424   // added in 1.0.0.22
+#define IOCTL_FD_SET_SECTOR_OFFSET      FD_CTL_CODE(0x90a, METHOD_BUFFERED)     // 0x0022e428   // added in 1.0.0.22
+#define IOCTL_FD_SET_HEAD_SETTLE_TIME   FD_CTL_CODE(0x90b, METHOD_BUFFERED)     // 0x0022e42c   // added in 1.0.0.22
+#define IOCTL_FD_LOCK_FDC               FD_CTL_CODE(0x910, METHOD_BUFFERED)     // 0x0022e440   // obsolete from 1.0.1.0
+#define IOCTL_FD_UNLOCK_FDC             FD_CTL_CODE(0x911, METHOD_BUFFERED)     // 0x0022e444   // obsolete from 1.0.1.0
+#define IOCTL_FD_MOTOR_ON               FD_CTL_CODE(0x912, METHOD_BUFFERED)     // 0x0022e448
+#define IOCTL_FD_MOTOR_OFF              FD_CTL_CODE(0x913, METHOD_BUFFERED)     // 0x0022e44c
+#define IOCTL_FD_WAIT_INDEX             FD_CTL_CODE(0x914, METHOD_BUFFERED)     // 0x0022e450   // added in 1.0.0.22
+#define IOCTL_FD_TIMED_SCAN_TRACK       FD_CTL_CODE(0x915, METHOD_BUFFERED)     // 0x0022e454   // added in 1.0.0.22
+#define IOCTL_FD_RAW_READ_TRACK         FD_CTL_CODE(0x916, METHOD_OUT_DIRECT)   // 0x0022e45a   // added in 1.0.1.4
+#define IOCTL_FD_CHECK_DISK             FD_CTL_CODE(0x917, METHOD_BUFFERED)     // 0x0022e45c   // added in 1.0.1.10
+#define IOCTL_FD_GET_TRACK_TIME         FD_CTL_CODE(0x918, METHOD_BUFFERED)     // 0x0022e460   // added in 1.0.1.10
+
+///////////////////////////////////////////////////////////////////////////////
+
+// Command flags: multi-track, MFM, sector skip, relative seek direction, verify enable count
+#define FD_OPTION_MT        0x80
+#define FD_OPTION_MFM       0x40
+#define FD_OPTION_SK        0x20
+#define FD_OPTION_DIR       0x40
+#define FD_OPTION_EC        0x01
+#define FD_OPTION_FM        0x00
+#define FD_ENCODING_MASK    FD_OPTION_MFM
+
+// Controller data rates, for use with IOCTL_FD_SET_DATA_RATE
+#define FD_RATE_MASK        3
+#define FD_RATE_500K        0
+#define FD_RATE_300K        1
+#define FD_RATE_250K        2
+#define FD_RATE_1M          3
+
+// FD_FDC_INFO controller types
+#define FDC_TYPE_UNKNOWN    0
+#define FDC_TYPE_UNKNOWN2   1
+#define FDC_TYPE_NORMAL     2
+#define FDC_TYPE_ENHANCED   3
+#define FDC_TYPE_82077      4
+#define FDC_TYPE_82077AA    5
+#define FDC_TYPE_82078_44   6
+#define FDC_TYPE_82078_64   7
+#define FDC_TYPE_NATIONAL   8
+
+// Bits representing supported data rates, for the FD_FDC_INFO structure below
+#define FDC_SPEED_250K      0x01
+#define FDC_SPEED_300K      0x02
+#define FDC_SPEED_500K      0x04
+#define FDC_SPEED_1M        0x08
+#define FDC_SPEED_2M        0x10
+
+
+#pragma pack(push,1)
+#pragma warning(push)
+#pragma warning(disable:4200)           // allow zero-sized arrays
+
+
+typedef struct tagFD_ID_HEADER
+{
+    BYTE cyl, head, sector, size;
+}
+FD_ID_HEADER, *PFD_ID_HEADER;
+
+typedef struct tagFD_SEEK_PARAMS
+{
+    BYTE cyl;
+    BYTE head;
+}
+FD_SEEK_PARAMS, *PFD_SEEK_PARAMS;
+
+typedef struct tagFD_RELATIVE_SEEK_PARAMS
+{
+    BYTE flags;                         // DIR
+    BYTE head;
+    BYTE offset;
+}
+FD_RELATIVE_SEEK_PARAMS, *PFD_RELATIVE_SEEK_PARAMS;
+
+typedef struct tagFD_READ_WRITE_PARAMS
+{
+    BYTE flags;                         // MT MFM SK
+    BYTE phead;
+    BYTE cyl, head, sector, size;
+    BYTE eot, gap, datalen;
+}
+FD_READ_WRITE_PARAMS, *PFD_READ_WRITE_PARAMS;
+
+typedef struct tagFD_CMD_RESULT
+{
+    BYTE st0, st1, st2;
+    BYTE cyl, head, sector, size;
+}
+FD_CMD_RESULT, *PFD_CMD_RESULT;
+
+typedef struct tagFD_FORMAT_PARAMS
+{
+    BYTE flags;                         // MFM
+    BYTE phead;
+    BYTE size, sectors, gap, fill;
+
+    FD_ID_HEADER Header[];
+}
+FD_FORMAT_PARAMS, *PFD_FORMAT_PARAMS;
+
+typedef struct tagFD_READ_ID_PARAMS
+{
+    BYTE flags;                         // MFM
+    BYTE head;
+}
+FD_READ_ID_PARAMS, *PFD_READ_ID_PARAMS;
+
+typedef struct tagFD_CONFIGURE_PARAMS
+{
+    BYTE eis_efifo_poll_fifothr;        // b6 = enable implied seek, b5 = enable fifo, b4 = poll disable, b3-b0 = fifo threshold
+    BYTE pretrk;                        // precompensation start track
+}
+FD_CONFIGURE_PARAMS, *PFD_CONFIGURE_PARAMS;
+
+typedef struct tagFD_SPECIFY_PARAMS
+{
+    BYTE srt_hut;                       // b7-b4 = step rate, b3-b0 = head unload time
+    BYTE hlt_nd;                        // b7-b1 = head load time, b0 = non-DMA flag (unsupported)
+}
+FD_SPECIFY_PARAMS, *PFD_SPECIFY_PARAMS;
+
+typedef struct tagFD_SENSE_PARAMS
+{
+    BYTE head;
+}
+FD_SENSE_PARAMS, *PFD_SENSE_PARAMS;
+
+typedef struct tagFD_DRIVE_STATUS
+{
+    BYTE st3;
+}
+FD_DRIVE_STATUS, *PFD_DRIVE_STATUS;
+
+typedef struct tagFD_INTERRUPT_STATUS
+{
+    BYTE st0;                           // status register 0
+    BYTE pcn;                           // present cylinder number
+}
+FD_INTERRUPT_STATUS, *PFD_INTERRUPT_STATUS;
+
+typedef struct tagFD_PERPENDICULAR_PARAMS
+{
+    BYTE ow_ds_gap_wgate;               // b7 = OW, b6 = 0, b5-b2 = drive select, b1 = gap2, b0 = write gate pre-erase loads
+}
+FD_PERPENDICULAR_PARAMS, *PFD_PERPENDICULAR_PARAMS;
+
+typedef struct tagFD_LOCK_PARAMS
+{
+    BYTE lock;                          // b7 = lock
+}
+FD_LOCK_PARAMS, *PFD_LOCK_PARAMS;
+
+typedef struct tagFD_LOCK_RESULT
+{
+    BYTE lock;                          // b4 = lock
+}
+FD_LOCK_RESULT, *PFD_LOCK_RESULT;
+
+typedef struct tagFD_DUMPREG_RESULT
+{
+    BYTE pcn0, pcn1, pcn2, pcn3;        // present cylinder numbers
+    BYTE srt_hut;                       // b7-4 = step rate, b3-0 = head unload time
+    BYTE hlt_nd;                        // b7-1 = head load time, b0 = non-dma mode
+    BYTE sceot;                         // sector count / end of track
+    BYTE lock_d0123_gap_wgate;          // b7 = setting lock, b5-2 = drive selects, b1 = gap 2 (perpendicular), b0 = write gate
+    BYTE eis_efifo_poll_fifothr;        // b6 = implied seeks, b5 = fifo enable, b4 = poll disable, b3-0 = fifo threshold
+    BYTE pretrk;                        // pre-comp start track
+}
+FD_DUMPREG_RESULT, *PFD_DUMPREG_RESULT;
+
+typedef struct tagFD_SECTOR_OFFSET_PARAMS
+{
+    BYTE sectors;                       // number of sectors to skip after index
+}
+FD_SECTOR_OFFSET_PARAMS, *PFD_SECTOR_OFFSET_PARAMS;
+
+typedef struct tagFD_SHORT_WRITE_PARAMS
+{
+    DWORD length;                       // length to write before interrupting
+    DWORD finetune;                     // finetune delay in microseconds
+}
+FD_SHORT_WRITE_PARAMS, *PFD_SHORT_WRITE_PARAMS;
+
+typedef struct tagFD_SCAN_PARAMS
+{
+    BYTE flags;                         // MFM
+    BYTE head;
+}
+FD_SCAN_PARAMS, *PFD_SCAN_PARAMS;
+
+typedef struct tagFD_SCAN_RESULT
+{
+    BYTE count;                         // count of returned headers
+    FD_ID_HEADER Header[];              // array of 'count' id fields
+}
+FD_SCAN_RESULT, *PFD_SCAN_RESULT;
+
+
+typedef struct tagFD_TIMED_ID_HEADER
+{
+    DWORD reltime;                      // time relative to index (in microseconds)
+    BYTE cyl, head, sector, size;
+}
+FD_TIMED_ID_HEADER, *PFD_TIMED_ID_HEADER;
+
+typedef struct tagFD_TIMED_SCAN_RESULT
+{
+    BYTE count;                         // count of returned headers
+    BYTE firstseen;                     // offset of first sector detected
+    DWORD tracktime;                    // total time for track (in microseconds)
+    FD_TIMED_ID_HEADER Header[];        // array of 'count' id fields
+}
+FD_TIMED_SCAN_RESULT, *PFD_TIMED_SCAN_RESULT;
+
+typedef struct tagFD_FDC_INFO
+{
+    BYTE ControllerType;                // FDC_TYPE_*
+    BYTE SpeedsAvailable;               // FDC_SPEED_* values ORed together
+
+    BYTE BusType;
+    DWORD BusNumber;
+    DWORD ControllerNumber;
+    DWORD PeripheralNumber;
+}
+FD_FDC_INFO, *PFD_FDC_INFO;
+
+typedef struct tagFD_RAW_READ_PARAMS
+{
+    BYTE flags;                         // MFM
+    BYTE head, size;
+}
+FD_RAW_READ_PARAMS, *PFD_RAW_READ_PARAMS;
+
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif  // FDRAWCMD_H
diff --git a/third_party/akaiutil/gpl-2.0.txt b/third_party/akaiutil/gpl-2.0.txt
new file mode 100755
index 0000000..d159169
--- /dev/null
+++ b/third_party/akaiutil/gpl-2.0.txt
@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.