In this work, we address the task of table image to LaTeX code generation, with the goal of automating the reconstruction of high-quality, publication-ready tables from visual inputs. A central challenge of this task lies in accurately handling complex tables—those with large sizes, deeply nested structures, and semantically rich or irregular cell content—where existing methods often fail. We begin with a comprehensive analysis, identifying key challenges and highlighting the limitations of current evaluation protocols. To overcome these issues, we propose a reinforced multimodal large language model (MLLM) framework, where a pre-trained MLLM is fine-tuned on a large-scale table-to-LaTeX dataset. To further improve generation quality, we introduce a dual-reward reinforcement learning strategy based on Group Relative Policy Optimization (GRPO). Unlike standard approaches that optimize purely over text outputs, our method incorporates both a structure-level reward on LaTeX code and a visual fidelity reward computed from rendered outputs, enabling direct optimization of the visual output quality. We adopt a hybrid evaluation protocol combining TEDS-Structure and CW-SSIM, and show that our method achieves state-of-the-art performance, particularly on structurally complex tables, demonstrating the effectiveness and robustness of our approach.

Abstract Cross‐dataset object detection methods can adapt to the needs of rapid category expansion in object detection tasks. However, these methods are prone to generate dataset‐aware errors with false alarm objects. This study is aimed to address these issues. A box‐separated multiple‐head module and box‐separated loss function based on the YOLOv8 network are devised to achieve cross‐dataset object detection. Additionally, a sameclass‐aware fusion module to avoid gradient conflicts due to cross‐category conflicts is developed. A multiple‐head fusion module is devised to reduce the number of false alarm objects caused by dataset‐aware errors. A global class‐aware sampler is also designed to adapt to the impact of the imbalanced number of categories and training samples across datasets. The effectiveness of the box‐separated multiple‐head module is verified using cross‐datasets built using the COCO, WiderFace, WiderPerson, and OpenImages V4 datasets. Extensive experiments demonstrate the efficiency and precision of the proposed method.

Traditional deadlock detection algorithms depend on finding cycles in lock graphs created from the application code. Usually, these approaches suffer from scalability and performance problems and cannot handle large industrial strength applications. The main problem for lack of scalability and poor performance is caused by the size of the lock graphs that have to be analyzed. In this paper we show a new two-phase deadlock detection algorithm that is efficient both in terms of memory utilization and time and also very scalable. In the first phase of the algorithm we consider a reduced lock graph based on program locations. We filter out certain locks that cannot participate in a deadlock by analyzing the lock graph created in the first phase. In the second phase of the algorithm we create an even smaller lock graph considering only those locks that were not filtered in the first phase. Finally, the second phase lock graph is analyzed for cycles to find potential deadlocks in the application. We present results from various open-source and commercial software, and also compare the performance of our algorithm with traditional approach.

Multithreading and concurrency are core features of the Java language. However, writing a correct concurrent program is notoriously difficult and error prone. Therefore, developing effective techniques to find concurrency bugs is very important. Existing static analysis techniques for finding concurrency bugs either sacrifice precision for performance, leading to many false positives, or require sophisticated analysis that incur significant overhead. In this paper, we present a precise and efficient static concurrency bugs detector building upon the Eclipse JDT and the open source WALA toolkit (which provides advanced static analysis capabilities). Our detector uses different implementation strategies to consider different types of concurrency bugs. We either utilize JDT to syntactically examine source code, or leverage WALA to perform interprocedural data flow analysis. We describe a variety of novel heuristics and enhancements to existing analysis techniques which make our detector more practical, in terms of accuracy and performance. We also present an effective approach to create inter-procedural data flow analysis using WALA for complex analysis. Finally we justify our claims by presenting the results of applying our detector to a range of real-world applications and comparing our detector with other tools.