diff --git a/bin/publish-latest-branch-build.php b/bin/publish-latest-branch-build.php
index 1ce874c..49da3dd 100755
--- a/bin/publish-latest-branch-build.php
+++ b/bin/publish-latest-branch-build.php
@@ -1,243 +1,249 @@
 #!/usr/bin/env php
 <?php
 ################################################################
 # This script is supposed to be executed by Phorge's Harbormaster,
 # from the directory of the leased working copy, on top of the
 # desired commit.
 #
 # Algorithm:
 #   - read the secret environment variables
 #   - for each APK:
 #     - make fingerprint
 #     - sign APK
 #     - move to the HTTP area
 #   - finally, if we are on a patch page:
 #     - publish a nice comment on Phorge on the patch page
 ################################################################
 
 // Die violently in case of any errors.
 require __DIR__ . '/../include/autoload.php';
 
 // Get environment variables.
 // These environment variables are very secret and passed to this script
 // using traditional Unix variable export.
 // These variables SHOULD be stored in a file that has very hardened permissions like
 // chmod 600, or similar.
 // Note that this PHP script does not know the .env filename. We just receive the env vars.
 // We die violently if a env variable does not exist (or if it's empty).
 // These are parsed earlier so to crash at startup.
 $KEYSTORE_PATH       = require_env('KEYSTORE_PATH');       // to sign the APK files
 $KEYSTORE_PASSPHRASE = require_env('KEYSTORE_PASSPHRASE'); // to sign the APK files
 $ARTIFACTS_PATH      = require_env('ARTIFACTS_PATH');      // to expose APK files on the web
 $ARTIFACTS_URL       = require_env('ARTIFACTS_URL');       // to download APK files from the web
 
 // Set he pathname to the repository built apk file(s).
 $APK_PATH_GENERIC = './app/build/outputs/apk/gitpull/*.apk';
 
 // Set the expected base URL for the published APK files and its webroot path on the filesystem.
 
 // The first argument of the script is the Differential ID number,
 // or empty if we are a generic commit.
 $phorge_differential_id = $argv[1] ?? null;
 
 // Show the current directory.
 // This is supposed to be a /var/drydock/repo/something and it's automatically
 // created by Harbormaster during the repository leasing.
 print_log_info(sprintf(
 	"Current directory: %s",
 	getcwd()
 ));
 
 // Get the branch name, and the Phorge document id of the page to be commented.
 $phorge_document_id = '';
 $branch_name = null;
 if ($phorge_differential_id) {
 	// We are coming from a Differential revision page.
 	// The first argument is "123", that is, the "D123" revision page.
 	// We assume that as branch name, to create nice APK names.
 	$branch_name = 'D' . $phorge_differential_id;
 	$phorge_document_id = $branch_name;
 } else {
 	// We are coming from a generic commit, not created from Differential.
 	// Get the git ref name (probably "HEAD").
 	$remote_shit = shell_line('git', [
 		'name-rev',
 		'--name-only',
 		'HEAD',
 	]);
 	$branch_name = basename($remote_shit);
 }
 
 // Get the git commit hash and title.
 // TODO: get also the author name.
 $git_commit = shell_line('git', [
 	'rev-parse',
 	'HEAD',
 ]);
 $git_commit_title = shell_line('git', [
 	'show',
 	'--pretty=format:%s',
 	'-s',
 	'HEAD',
 ]);
 
 // Find every single APK and generate core info.
 $generated_apks = [];
 
 // No APK, no party.
 $apk_founds = glob($APK_PATH_GENERIC);
 if (!$apk_founds) {
 	print_log_error("No APK Founds. WTF!?");
 	exit(1);
 }
 
 // Process every single APK.
 foreach (glob($APK_PATH_GENERIC) as $apk_raw_path) {
 
 	// Get the original name of the APK, produced by gradle.
 	// Example: 'apk-amd64-unsigned.apk'.
 	$apk_raw_name = basename($apk_raw_path);
 
 	// Build the "branch-apk-amd64-unsigned.apk" filename, branch prefixed.
 	// We remove "-unsigned" from the filename since it would be weird.
 	$apk_raw_destination_name = "{$branch_name}-{$apk_raw_name}";
 	$apk_raw_destination_path = $ARTIFACTS_PATH . '/' . $apk_raw_destination_name;
 
 	// Create a version of this APK name without that '-unsigned' that is nonsense asd.
 	// From: 'apk-amd64-unsigned.apk'
 	// To:   'apk-amd64.apk'
 	$apk_raw_name_clean = $apk_raw_destination_name;
 	$apk_raw_name_clean = str_replace('app-',      '', $apk_raw_name_clean);
 	$apk_raw_name_clean = str_replace('-gitpull',  '', $apk_raw_name_clean);
 	$apk_raw_name_clean = str_replace('-unsigned', '', $apk_raw_name_clean);
 
 	// From the raw APK we will build 2 artifacts (1 intermediate).
 	// The first is the "aligned" that is completely temporary and unuseful.
 	// The final is the "aligned-signed", downloadable and installable.
 	$apk_aligned_name        = add_file_suffix($apk_raw_name_clean, '-aligned');
 	$apk_aligned_path        = $ARTIFACTS_PATH . '/' . $apk_aligned_name;
-	$apk_aligned_signed_name = add_file_suffix($apk_raw_name_clean, '-aligned-signed');
+	$apk_aligned_signed_name = add_file_suffix($apk_raw_name_clean, '-signed');
 	$apk_aligned_signed_path = $ARTIFACTS_PATH . '/' . $apk_aligned_signed_name;
 	$apk_aligned_signed_url  = $ARTIFACTS_URL . $apk_aligned_signed_name;
 
 	// Calculate the signature of the raw APK. This may take some time.
 	// This is probably not useful, but useful for extra auditing of this log.
 	print_log_info("RAW APK {$apk_raw_name}: sha256sum: calculating...");
 	$apk_raw_sha256 = hash_file('sha256', $apk_raw_path);
 	print_log_info("RAW APK {$apk_raw_name}: sha256sum: calculated: $apk_raw_sha256");
 
 	// Expose the raw APK on the web, just because we can.
 	print_log_info("RAW APK {$apk_raw_name}: expose in HTTP destination");
 	copy($apk_raw_path, $apk_raw_destination_path);
 
 	// Run Android "ZIP align" on the raw APK.
 	// Publish it directly.
 	print_log_info("RAW APK {$apk_raw_name}: zipalign... creating {$apk_aligned_name}");
 	passthru(sprintf(
 		'~/bin/zipalign -p -f -v 4 %s %s',
 		escapeshellarg($apk_raw_path), // Input
 		escapeshellarg($apk_aligned_path) // Output
 	));
 
 	// Sign the aligned APK.
 	// Publish it directly.
 	print_log_info("APK ALIGNED {$apk_aligned_name}: apksigner... creating {$apk_aligned_signed_name}");
 	passthru(sprintf(
 		'~/bin/apksigner sign --ks %s --out %s --ks-pass pass:%s %s',
 		escapeshellarg($KEYSTORE_PATH),
 		escapeshellarg($apk_aligned_signed_path), // Output
 		escapeshellarg($KEYSTORE_PASSPHRASE),
 		escapeshellarg($apk_aligned_path) // Input
 	));
 
 	// Calculate the signature of the aligned signed APK. This may take some time.
 	print_log_info("APK ALIGNED SIGNED {$apk_aligned_signed_name}: calculating sha256sum...");
 	$apk_aligned_signed_sha256 = hash_file('sha256', $apk_aligned_signed_path);
 
+	$apk_abi = extractABIFromAPK($apk_raw_name);
 	// Clean old APK in the repository to never re-use it by mistake
 	// as it happened when we moved everything to the /app directory...
 	unlink($apk_raw_path);
 
 	// Remember this APK later and its signature.
-	$generated_apks[] = new APK($apk_aligned_signed_name, $apk_aligned_signed_url, $apk_aligned_signed_sha256);
+	$generated_apks[] = new APK($apk_aligned_signed_name, $apk_aligned_signed_url, $apk_aligned_signed_sha256, $apk_abi);
 }
 
 // Overwrite the latest git show for this branch name (force date update).
 $BUILD_GIT_SHOW_FILE = $ARTIFACTS_PATH . '/' . $branch_name . '-git-show.txt';
 file_put_contents($BUILD_GIT_SHOW_FILE, shell_exec('git show'));
 
 // Build Phorge comment.
 // There is a fixed header, and multiple lines about each APK.
 $telegram_apk_lines = [];
 $phorge_apk_lines   = [];
 foreach ($generated_apks as $generated_apk) {
+
+	if($generated_apk->$ABI != null)
+		$telegram_apk_lines[] = "APK for {$generated_apk->$ABI}:";
 	foreach ($generated_apk->getTelegramCommentLines() as $apk_line) {
 		$telegram_apk_lines[] = $apk_line;
-		$telegram_apk_lines[] = "";
+		//$telegram_apk_lines[] = "";
 	}
+	$telegram_apk_lines[] = "";
+
 	foreach ($generated_apk->getPhorgeCommentLines() as $apk_line) {
 		$phorge_apk_lines[] = $apk_line;
 		$phorge_apk_lines[] = "";
 	}
 }
 $telegram_apk_lines_str = implode("\n", $telegram_apk_lines);
 $phorge_apk_lines_str   = implode("\n", $phorge_apk_lines);
 
 // add a comment to the build URL
 if (!empty($phorge_document_id) && empty(getenv('NO_COMMENT'))) {
 	// We have a Differentials revision under review!
 	$telegram_chat_content = implode("\n", [
 		// In Telegram, normal text must be escaped. Link destinations must not be escaped.
 		TelegramStupidSDK::escapeMarkdownV2("⚙ Dear Android hackers, please review this promising patch:"),
 		TelegramStupidSDK::escapeMarkdownV2("https://gitpull.it/$phorge_document_id"),
 		"",
 		TelegramStupidSDK::escapeMarkdownV2("Here the related fresh test builds:"),
 		"",
 		// The texts in these links are already escaped.
 		$telegram_apk_lines_str,
 	]);
 
 	// Send message to Telegram groups.
 	echo "DEBUG TELEGRAM CONTENT\n";
 	echo "$telegram_chat_content\n";
 
 	// Send message to your default Telegram group.
 	// See the TELEGRAM_* environment variables.
 	(new TelegramStupidSDK())->sendMessage($telegram_chat_content);
 
 	// Send message to Phorge.
 	echo "Adding bipbop Comment to $phorge_document_id\n";
 	shell_exec(sprintf(
 		"~/bin/phab-comment.php %s %s %s",
 		escapeshellarg($phorge_document_id),
 		escapeshellarg($apk_aligned_signed_url),
 		escapeshellarg($apk_raw_sha256)
 	));
 } else {
 	// We have NOT a Differentials revision under review!
 	// So this is an atomic commit.
 	$telegram_chat_content = implode("\n", [
 		"🌚 New commit: *$git_commit_title*",
 		"https://gitpull.it/R4:$git_commit",
 		"",
 		"Here the related fresh test builds:",
 		"",
 		$telegram_apk_lines_str,
 	]);
 
 	echo "DEBUG TELEGRAM CONTENT\n";
 	echo "$telegram_chat_content\n";
 
 	// Send message to your default Telegram group.
 	// See the TELEGRAM_* environment variables.
 	(new TelegramStupidSDK())->sendMessage($telegram_chat_content);
 }
 
 // delete very old files
 print_log_info("Cleaning old artifacts");
 shell_exec(sprintf(
 	"find %s -type f -mtime +120 -delete",
 	escapeshellarg($ARTIFACTS_PATH)
 ));
 
 print_log_info("Done");
diff --git a/include/APK.php b/include/APK.php
index 7566293..bb22ec0 100644
--- a/include/APK.php
+++ b/include/APK.php
@@ -1,78 +1,81 @@
 <?php
 /**
  * Stupid class describing a single APK.
  */
 class APK {
 	private $name;
 	private $url;
 	private $sha256;
+	private $ABI;
 
 	/**
 	 * Constructor
 	 */
-	public function __construct($name, $url, $sha256) {
+	public function __construct($name, $url, $sha256, $ABI) {
 		$this->name   = $name;
 		$this->url    = $url;
 		$this->sha256 = $sha256;
+		$this->ABI = $ABI;
 	}
 
 	/**
 	 * @return array
 	 */
 	public function getPhorgeCommentLines() {
 		return [
 			$this->getPhorgeDownloadLink(),
 			$this->getPhorgeAPKSignatureLine()
 		];
 	}
 
 	/**
 	 * @return array
 	 */
 	public function getTelegramCommentLines() {
 		return [
 			$this->getTelegramDownloadLink(),
 			$this->getPhorgeAPKSignatureLine()
 		];
 	}
 
 	/**
 	 * Get a very generic download link for Phorge.
 	 * @return string
 	 */
 	private function getPhorgeDownloadLink(): string {
 		return sprintf(
 			"[%s](%s)",
 			"Download {$this->name}",
 			$this->url
 		);
 	}
 
 	/**
 	 * Get a very generic download link for Phorge.
 	 * @return string
 	 */
 	private function getTelegramDownloadLink(): string {
 		// In Telegram it seems we must escape the link text from special characters.
 		// The link, instead, can be returned as-is.
 		// So the Text from: "Download asd.apk"
 		//               to: "Download asd\\.apk"
+		$tempname = basename($this->name);
 		return sprintf(
 			"[%s](%s)",
-			TelegramStupidSDK::escapeMarkdownV2("Download {$this->name}"),
+			TelegramStupidSDK::escapeMarkdownV2("Download {$tempname}"),
 			$this->url
 		);
 	}
 
 	/**
 	 * Get a very generic line about the sha256sum of this APK.
 	 * @return string
 	 */
 	private function getPhorgeAPKSignatureLine() {
 		// NOTE: if you write a ":" here, Telegram will crash. Sanitize it for Telegram asd.
 		return sprintf(
-			"APK sha256 `%s`",
+			"APK sha256: `%s`",
 			$this->sha256
 		);
 	}
 }
diff --git a/include/functions.php b/include/functions.php
index 7a534aa..556da33 100644
--- a/include/functions.php
+++ b/include/functions.php
@@ -1,141 +1,153 @@
 <?php
 
 /**
  * Require a specific environment variable or scream violently.
  * @param $name string Environment variable name
  * @return Environment variable value
  */
 function require_env($name) {
 	$value = getenv($name);
 	if (!$value) {
 		throw new Exception(sprintf(
 			"Missing ENV variable '%s'",
 			$name
 		));
 	}
 	return $value;
 }
 
 /**
  * Take a file and append a suffix.
  * @param string $file   E.g. 'asd.apk'
  * @param string $suffix E.g. '-lol'
  * @return string 'asd-lol.apk'
  */
 function add_file_suffix($file, $suffix) {
 	// Get the file extension (.apk).
 	$ext = pathinfo($file, PATHINFO_EXTENSION);
 	$ext = ".$ext";
 
 	// Get the filename without the extension.
 	$filenameWithoutExt = basename($file, $ext);
 
 	// Return the new file path with the suffix added.
 	return $filenameWithoutExt . $suffix . $ext;
 }
 
 /**
  * Execute a command and get standard output, standard error,
  * and exit status code.
  * Credits: https://www.darklaunch.com/php-exec-stderr-stdout-return-code.html
  * @return CommandResult
  */
 function shell_complete(string $cmd, array $args = [], $input = ''): CommandResult {
 
 	// Build a safe command line.
 	$complete_cmd = build_shell_line($cmd, $args);
 
 	$proc = proc_open($complete_cmd, [
 		['pipe', 'r'],
 		['pipe', 'w'],
 		['pipe', 'w']
 	], $pipes);
 	fwrite($pipes[0], $input);
 	fclose($pipes[0]);
 
 	$stdout = stream_get_contents($pipes[1]);
 	fclose($pipes[1]);
 
 	$stderr = stream_get_contents($pipes[2]);
 	fclose($pipes[2]);
 
 	$return_code = (int)proc_close($proc);
 
 	// Don't proceed in case of errors.
 	if ($return_code !== 0) {
 		throw new Exception(sprintf(
 			"Failed executing command starting with: %s and with %d arguments",
 			$cmd,
 			count($args)
 		));
 	}
 
 	// Forward the standard error as-is.
 	if ($stderr !== '') {
 		file_put_contents('php://stderr', $stderr);
 	}
 
 	return new CommandResult($return_code, $stdout, $stderr);
 }
 
 function build_shell_line(string $command, array $args = []): string {
 	$cmd_parts = [];
 	$cmd_parts[] = escapeshellcmd($command);
 	foreach ($args as $arg) {
 		$cmd_parts[] = escapeshellarg($arg);
 	}
 	return implode(' ', $cmd_parts);
 }
 
 /**
  * Execute a shell command and get all output lines.
  * @param string $command e.g. 'git'
  * @param string $args Command line arguments not-escaped (we will escape them) e.g. ['status']
  * @return array All lines of output from git status.
  */
 function shell_lines($command, array $args) {
 	$result = shell_complete($command, $args);
 	return explode("\n", $result->stdout);
 }
 
 /**
  * Execute a shell command and get the first output line.
  * @param string $command e.g. 'git'
  * @param string $args Command line arguments not-escaped (we will escape them) e.g. ['status']
  * @return string First line of output from git status.
  */
 function shell_line(string $command, array $args) {
 	$lines = shell_lines($command, $args);
 	foreach ($lines as $line) {
 		return trim($line);
 	}
 	return null;
 }
 
 /**
  * Show a stupidly formatted log line.
  * @param string $msg
  */
 function print_log($level, $msg) {
 	printf("[%s][%s] %s\n",
 		$level,
 		date('Y-m-d H:i:s'),
 		$msg
 	);
 }
 
 /**
  * Show a stupidly formatted log INFO line.
  * @param string $msg
  */
 function print_log_info($msg) {
 	print_log('INFO', $msg);
 }
 
 /**
  * Show a stupidly formatted log ERROR line.
  * @param string $msg
  */
 function print_log_error($msg) {
 	print_log('ERROR', $msg);
 }
+
+function extractABIFromAPK($filename) {
+  $start = strpos($filename, "app-");
+  $end = strpos($filename, "-gitpull");
+
+  if ($start !== false && $end !== false && $end > $start + 4) {
+    return substr($filename, $start + 4, $end - ($start + 4));
+  } else {
+    return null; // Or handle the case where the pattern is not found differently
+  }
+}
+